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

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

/**
 * @enum {number}
 */
TFLITE.TensorType = {
  FLOAT32: 0,
  FLOAT16: 1,
  INT32: 2,
  UINT8: 3,
  INT64: 4,
  STRING: 5,
  BOOL: 6,
  INT16: 7,
  COMPLEX64: 8,
  INT8: 9,
  FLOAT64: 10
};

/**
 * @enum {string}
 */
TFLITE.TensorTypeName = {
  '0': 'FLOAT32',
  '1': 'FLOAT16',
  '2': 'INT32',
  '3': 'UINT8',
  '4': 'INT64',
  '5': 'STRING',
  '6': 'BOOL',
  '7': 'INT16',
  '8': 'COMPLEX64',
  '9': 'INT8',
  '10': 'FLOAT64'
};

/**
 * @enum {number}
 */
TFLITE.QuantizationDetails = {
  NONE: 0,
  CustomQuantization: 1
};

/**
 * @enum {string}
 */
TFLITE.QuantizationDetailsName = {
  '0': 'NONE',
  '1': 'CustomQuantization'
};

/**
 * @enum {number}
 */
TFLITE.DimensionType = {
  DENSE: 0,
  SPARSE_CSR: 1
};

/**
 * @enum {string}
 */
TFLITE.DimensionTypeName = {
  '0': 'DENSE',
  '1': 'SPARSE_CSR'
};

/**
 * @enum {number}
 */
TFLITE.SparseIndexVector = {
  NONE: 0,
  Int32Vector: 1,
  Uint16Vector: 2,
  Uint8Vector: 3
};

/**
 * @enum {string}
 */
TFLITE.SparseIndexVectorName = {
  '0': 'NONE',
  '1': 'Int32Vector',
  '2': 'Uint16Vector',
  '3': 'Uint8Vector'
};

/**
 * @enum {number}
 */
TFLITE.BuiltinOperator = {
  ADD: 0,
  AVERAGE_POOL_2D: 1,
  CONCATENATION: 2,
  CONV_2D: 3,
  DEPTHWISE_CONV_2D: 4,
  DEPTH_TO_SPACE: 5,
  DEQUANTIZE: 6,
  EMBEDDING_LOOKUP: 7,
  FLOOR: 8,
  FULLY_CONNECTED: 9,
  HASHTABLE_LOOKUP: 10,
  L2_NORMALIZATION: 11,
  L2_POOL_2D: 12,
  LOCAL_RESPONSE_NORMALIZATION: 13,
  LOGISTIC: 14,
  LSH_PROJECTION: 15,
  LSTM: 16,
  MAX_POOL_2D: 17,
  MUL: 18,
  RELU: 19,
  RELU_N1_TO_1: 20,
  RELU6: 21,
  RESHAPE: 22,
  RESIZE_BILINEAR: 23,
  RNN: 24,
  SOFTMAX: 25,
  SPACE_TO_DEPTH: 26,
  SVDF: 27,
  TANH: 28,
  CONCAT_EMBEDDINGS: 29,
  SKIP_GRAM: 30,
  CALL: 31,
  CUSTOM: 32,
  EMBEDDING_LOOKUP_SPARSE: 33,
  PAD: 34,
  UNIDIRECTIONAL_SEQUENCE_RNN: 35,
  GATHER: 36,
  BATCH_TO_SPACE_ND: 37,
  SPACE_TO_BATCH_ND: 38,
  TRANSPOSE: 39,
  MEAN: 40,
  SUB: 41,
  DIV: 42,
  SQUEEZE: 43,
  UNIDIRECTIONAL_SEQUENCE_LSTM: 44,
  STRIDED_SLICE: 45,
  BIDIRECTIONAL_SEQUENCE_RNN: 46,
  EXP: 47,
  TOPK_V2: 48,
  SPLIT: 49,
  LOG_SOFTMAX: 50,
  DELEGATE: 51,
  BIDIRECTIONAL_SEQUENCE_LSTM: 52,
  CAST: 53,
  PRELU: 54,
  MAXIMUM: 55,
  ARG_MAX: 56,
  MINIMUM: 57,
  LESS: 58,
  NEG: 59,
  PADV2: 60,
  GREATER: 61,
  GREATER_EQUAL: 62,
  LESS_EQUAL: 63,
  SELECT: 64,
  SLICE: 65,
  SIN: 66,
  TRANSPOSE_CONV: 67,
  SPARSE_TO_DENSE: 68,
  TILE: 69,
  EXPAND_DIMS: 70,
  EQUAL: 71,
  NOT_EQUAL: 72,
  LOG: 73,
  SUM: 74,
  SQRT: 75,
  RSQRT: 76,
  SHAPE: 77,
  POW: 78,
  ARG_MIN: 79,
  FAKE_QUANT: 80,
  REDUCE_PROD: 81,
  REDUCE_MAX: 82,
  PACK: 83,
  LOGICAL_OR: 84,
  ONE_HOT: 85,
  LOGICAL_AND: 86,
  LOGICAL_NOT: 87,
  UNPACK: 88,
  REDUCE_MIN: 89,
  FLOOR_DIV: 90,
  REDUCE_ANY: 91,
  SQUARE: 92,
  ZEROS_LIKE: 93,
  FILL: 94,
  FLOOR_MOD: 95,
  RANGE: 96,
  RESIZE_NEAREST_NEIGHBOR: 97,
  LEAKY_RELU: 98,
  SQUARED_DIFFERENCE: 99,
  MIRROR_PAD: 100,
  ABS: 101,
  SPLIT_V: 102,
  UNIQUE: 103,
  CEIL: 104,
  REVERSE_V2: 105,
  ADD_N: 106,
  GATHER_ND: 107,
  COS: 108,
  WHERE: 109,
  RANK: 110,
  ELU: 111,
  REVERSE_SEQUENCE: 112,
  MATRIX_DIAG: 113,
  QUANTIZE: 114,
  MATRIX_SET_DIAG: 115,
  ROUND: 116,
  HARD_SWISH: 117,
  IF: 118,
  WHILE: 119,
  NON_MAX_SUPPRESSION_V4: 120,
  NON_MAX_SUPPRESSION_V5: 121,
  SCATTER_ND: 122,
  SELECT_V2: 123,
  DENSIFY: 124,
  SEGMENT_SUM: 125,
  BATCH_MATMUL: 126
};

/**
 * @enum {string}
 */
TFLITE.BuiltinOperatorName = {
  '0': 'ADD',
  '1': 'AVERAGE_POOL_2D',
  '2': 'CONCATENATION',
  '3': 'CONV_2D',
  '4': 'DEPTHWISE_CONV_2D',
  '5': 'DEPTH_TO_SPACE',
  '6': 'DEQUANTIZE',
  '7': 'EMBEDDING_LOOKUP',
  '8': 'FLOOR',
  '9': 'FULLY_CONNECTED',
  '10': 'HASHTABLE_LOOKUP',
  '11': 'L2_NORMALIZATION',
  '12': 'L2_POOL_2D',
  '13': 'LOCAL_RESPONSE_NORMALIZATION',
  '14': 'LOGISTIC',
  '15': 'LSH_PROJECTION',
  '16': 'LSTM',
  '17': 'MAX_POOL_2D',
  '18': 'MUL',
  '19': 'RELU',
  '20': 'RELU_N1_TO_1',
  '21': 'RELU6',
  '22': 'RESHAPE',
  '23': 'RESIZE_BILINEAR',
  '24': 'RNN',
  '25': 'SOFTMAX',
  '26': 'SPACE_TO_DEPTH',
  '27': 'SVDF',
  '28': 'TANH',
  '29': 'CONCAT_EMBEDDINGS',
  '30': 'SKIP_GRAM',
  '31': 'CALL',
  '32': 'CUSTOM',
  '33': 'EMBEDDING_LOOKUP_SPARSE',
  '34': 'PAD',
  '35': 'UNIDIRECTIONAL_SEQUENCE_RNN',
  '36': 'GATHER',
  '37': 'BATCH_TO_SPACE_ND',
  '38': 'SPACE_TO_BATCH_ND',
  '39': 'TRANSPOSE',
  '40': 'MEAN',
  '41': 'SUB',
  '42': 'DIV',
  '43': 'SQUEEZE',
  '44': 'UNIDIRECTIONAL_SEQUENCE_LSTM',
  '45': 'STRIDED_SLICE',
  '46': 'BIDIRECTIONAL_SEQUENCE_RNN',
  '47': 'EXP',
  '48': 'TOPK_V2',
  '49': 'SPLIT',
  '50': 'LOG_SOFTMAX',
  '51': 'DELEGATE',
  '52': 'BIDIRECTIONAL_SEQUENCE_LSTM',
  '53': 'CAST',
  '54': 'PRELU',
  '55': 'MAXIMUM',
  '56': 'ARG_MAX',
  '57': 'MINIMUM',
  '58': 'LESS',
  '59': 'NEG',
  '60': 'PADV2',
  '61': 'GREATER',
  '62': 'GREATER_EQUAL',
  '63': 'LESS_EQUAL',
  '64': 'SELECT',
  '65': 'SLICE',
  '66': 'SIN',
  '67': 'TRANSPOSE_CONV',
  '68': 'SPARSE_TO_DENSE',
  '69': 'TILE',
  '70': 'EXPAND_DIMS',
  '71': 'EQUAL',
  '72': 'NOT_EQUAL',
  '73': 'LOG',
  '74': 'SUM',
  '75': 'SQRT',
  '76': 'RSQRT',
  '77': 'SHAPE',
  '78': 'POW',
  '79': 'ARG_MIN',
  '80': 'FAKE_QUANT',
  '81': 'REDUCE_PROD',
  '82': 'REDUCE_MAX',
  '83': 'PACK',
  '84': 'LOGICAL_OR',
  '85': 'ONE_HOT',
  '86': 'LOGICAL_AND',
  '87': 'LOGICAL_NOT',
  '88': 'UNPACK',
  '89': 'REDUCE_MIN',
  '90': 'FLOOR_DIV',
  '91': 'REDUCE_ANY',
  '92': 'SQUARE',
  '93': 'ZEROS_LIKE',
  '94': 'FILL',
  '95': 'FLOOR_MOD',
  '96': 'RANGE',
  '97': 'RESIZE_NEAREST_NEIGHBOR',
  '98': 'LEAKY_RELU',
  '99': 'SQUARED_DIFFERENCE',
  '100': 'MIRROR_PAD',
  '101': 'ABS',
  '102': 'SPLIT_V',
  '103': 'UNIQUE',
  '104': 'CEIL',
  '105': 'REVERSE_V2',
  '106': 'ADD_N',
  '107': 'GATHER_ND',
  '108': 'COS',
  '109': 'WHERE',
  '110': 'RANK',
  '111': 'ELU',
  '112': 'REVERSE_SEQUENCE',
  '113': 'MATRIX_DIAG',
  '114': 'QUANTIZE',
  '115': 'MATRIX_SET_DIAG',
  '116': 'ROUND',
  '117': 'HARD_SWISH',
  '118': 'IF',
  '119': 'WHILE',
  '120': 'NON_MAX_SUPPRESSION_V4',
  '121': 'NON_MAX_SUPPRESSION_V5',
  '122': 'SCATTER_ND',
  '123': 'SELECT_V2',
  '124': 'DENSIFY',
  '125': 'SEGMENT_SUM',
  '126': 'BATCH_MATMUL'
};

/**
 * @enum {number}
 */
TFLITE.BuiltinOptions = {
  NONE: 0,
  Conv2DOptions: 1,
  DepthwiseConv2DOptions: 2,
  ConcatEmbeddingsOptions: 3,
  LSHProjectionOptions: 4,
  Pool2DOptions: 5,
  SVDFOptions: 6,
  RNNOptions: 7,
  FullyConnectedOptions: 8,
  SoftmaxOptions: 9,
  ConcatenationOptions: 10,
  AddOptions: 11,
  L2NormOptions: 12,
  LocalResponseNormalizationOptions: 13,
  LSTMOptions: 14,
  ResizeBilinearOptions: 15,
  CallOptions: 16,
  ReshapeOptions: 17,
  SkipGramOptions: 18,
  SpaceToDepthOptions: 19,
  EmbeddingLookupSparseOptions: 20,
  MulOptions: 21,
  PadOptions: 22,
  GatherOptions: 23,
  BatchToSpaceNDOptions: 24,
  SpaceToBatchNDOptions: 25,
  TransposeOptions: 26,
  ReducerOptions: 27,
  SubOptions: 28,
  DivOptions: 29,
  SqueezeOptions: 30,
  SequenceRNNOptions: 31,
  StridedSliceOptions: 32,
  ExpOptions: 33,
  TopKV2Options: 34,
  SplitOptions: 35,
  LogSoftmaxOptions: 36,
  CastOptions: 37,
  DequantizeOptions: 38,
  MaximumMinimumOptions: 39,
  ArgMaxOptions: 40,
  LessOptions: 41,
  NegOptions: 42,
  PadV2Options: 43,
  GreaterOptions: 44,
  GreaterEqualOptions: 45,
  LessEqualOptions: 46,
  SelectOptions: 47,
  SliceOptions: 48,
  TransposeConvOptions: 49,
  SparseToDenseOptions: 50,
  TileOptions: 51,
  ExpandDimsOptions: 52,
  EqualOptions: 53,
  NotEqualOptions: 54,
  ShapeOptions: 55,
  PowOptions: 56,
  ArgMinOptions: 57,
  FakeQuantOptions: 58,
  PackOptions: 59,
  LogicalOrOptions: 60,
  OneHotOptions: 61,
  LogicalAndOptions: 62,
  LogicalNotOptions: 63,
  UnpackOptions: 64,
  FloorDivOptions: 65,
  SquareOptions: 66,
  ZerosLikeOptions: 67,
  FillOptions: 68,
  BidirectionalSequenceLSTMOptions: 69,
  BidirectionalSequenceRNNOptions: 70,
  UnidirectionalSequenceLSTMOptions: 71,
  FloorModOptions: 72,
  RangeOptions: 73,
  ResizeNearestNeighborOptions: 74,
  LeakyReluOptions: 75,
  SquaredDifferenceOptions: 76,
  MirrorPadOptions: 77,
  AbsOptions: 78,
  SplitVOptions: 79,
  UniqueOptions: 80,
  ReverseV2Options: 81,
  AddNOptions: 82,
  GatherNdOptions: 83,
  CosOptions: 84,
  WhereOptions: 85,
  RankOptions: 86,
  ReverseSequenceOptions: 87,
  MatrixDiagOptions: 88,
  QuantizeOptions: 89,
  MatrixSetDiagOptions: 90,
  HardSwishOptions: 91,
  IfOptions: 92,
  WhileOptions: 93,
  DepthToSpaceOptions: 94,
  NonMaxSuppressionV4Options: 95,
  NonMaxSuppressionV5Options: 96,
  ScatterNdOptions: 97,
  SelectV2Options: 98,
  DensifyOptions: 99,
  SegmentSumOptions: 100,
  BatchMatMulOptions: 101
};

/**
 * @enum {string}
 */
TFLITE.BuiltinOptionsName = {
  '0': 'NONE',
  '1': 'Conv2DOptions',
  '2': 'DepthwiseConv2DOptions',
  '3': 'ConcatEmbeddingsOptions',
  '4': 'LSHProjectionOptions',
  '5': 'Pool2DOptions',
  '6': 'SVDFOptions',
  '7': 'RNNOptions',
  '8': 'FullyConnectedOptions',
  '9': 'SoftmaxOptions',
  '10': 'ConcatenationOptions',
  '11': 'AddOptions',
  '12': 'L2NormOptions',
  '13': 'LocalResponseNormalizationOptions',
  '14': 'LSTMOptions',
  '15': 'ResizeBilinearOptions',
  '16': 'CallOptions',
  '17': 'ReshapeOptions',
  '18': 'SkipGramOptions',
  '19': 'SpaceToDepthOptions',
  '20': 'EmbeddingLookupSparseOptions',
  '21': 'MulOptions',
  '22': 'PadOptions',
  '23': 'GatherOptions',
  '24': 'BatchToSpaceNDOptions',
  '25': 'SpaceToBatchNDOptions',
  '26': 'TransposeOptions',
  '27': 'ReducerOptions',
  '28': 'SubOptions',
  '29': 'DivOptions',
  '30': 'SqueezeOptions',
  '31': 'SequenceRNNOptions',
  '32': 'StridedSliceOptions',
  '33': 'ExpOptions',
  '34': 'TopKV2Options',
  '35': 'SplitOptions',
  '36': 'LogSoftmaxOptions',
  '37': 'CastOptions',
  '38': 'DequantizeOptions',
  '39': 'MaximumMinimumOptions',
  '40': 'ArgMaxOptions',
  '41': 'LessOptions',
  '42': 'NegOptions',
  '43': 'PadV2Options',
  '44': 'GreaterOptions',
  '45': 'GreaterEqualOptions',
  '46': 'LessEqualOptions',
  '47': 'SelectOptions',
  '48': 'SliceOptions',
  '49': 'TransposeConvOptions',
  '50': 'SparseToDenseOptions',
  '51': 'TileOptions',
  '52': 'ExpandDimsOptions',
  '53': 'EqualOptions',
  '54': 'NotEqualOptions',
  '55': 'ShapeOptions',
  '56': 'PowOptions',
  '57': 'ArgMinOptions',
  '58': 'FakeQuantOptions',
  '59': 'PackOptions',
  '60': 'LogicalOrOptions',
  '61': 'OneHotOptions',
  '62': 'LogicalAndOptions',
  '63': 'LogicalNotOptions',
  '64': 'UnpackOptions',
  '65': 'FloorDivOptions',
  '66': 'SquareOptions',
  '67': 'ZerosLikeOptions',
  '68': 'FillOptions',
  '69': 'BidirectionalSequenceLSTMOptions',
  '70': 'BidirectionalSequenceRNNOptions',
  '71': 'UnidirectionalSequenceLSTMOptions',
  '72': 'FloorModOptions',
  '73': 'RangeOptions',
  '74': 'ResizeNearestNeighborOptions',
  '75': 'LeakyReluOptions',
  '76': 'SquaredDifferenceOptions',
  '77': 'MirrorPadOptions',
  '78': 'AbsOptions',
  '79': 'SplitVOptions',
  '80': 'UniqueOptions',
  '81': 'ReverseV2Options',
  '82': 'AddNOptions',
  '83': 'GatherNdOptions',
  '84': 'CosOptions',
  '85': 'WhereOptions',
  '86': 'RankOptions',
  '87': 'ReverseSequenceOptions',
  '88': 'MatrixDiagOptions',
  '89': 'QuantizeOptions',
  '90': 'MatrixSetDiagOptions',
  '91': 'HardSwishOptions',
  '92': 'IfOptions',
  '93': 'WhileOptions',
  '94': 'DepthToSpaceOptions',
  '95': 'NonMaxSuppressionV4Options',
  '96': 'NonMaxSuppressionV5Options',
  '97': 'ScatterNdOptions',
  '98': 'SelectV2Options',
  '99': 'DensifyOptions',
  '100': 'SegmentSumOptions',
  '101': 'BatchMatMulOptions'
};

/**
 * @enum {number}
 */
TFLITE.Padding = {
  SAME: 0,
  VALID: 1
};

/**
 * @enum {string}
 */
TFLITE.PaddingName = {
  '0': 'SAME',
  '1': 'VALID'
};

/**
 * @enum {number}
 */
TFLITE.ActivationFunctionType = {
  NONE: 0,
  RELU: 1,
  RELU_N1_TO_1: 2,
  RELU6: 3,
  TANH: 4,
  SIGN_BIT: 5
};

/**
 * @enum {string}
 */
TFLITE.ActivationFunctionTypeName = {
  '0': 'NONE',
  '1': 'RELU',
  '2': 'RELU_N1_TO_1',
  '3': 'RELU6',
  '4': 'TANH',
  '5': 'SIGN_BIT'
};

/**
 * @enum {number}
 */
TFLITE.LSHProjectionType = {
  UNKNOWN: 0,
  SPARSE: 1,
  DENSE: 2
};

/**
 * @enum {string}
 */
TFLITE.LSHProjectionTypeName = {
  '0': 'UNKNOWN',
  '1': 'SPARSE',
  '2': 'DENSE'
};

/**
 * @enum {number}
 */
TFLITE.FullyConnectedOptionsWeightsFormat = {
  DEFAULT: 0,
  SHUFFLED4x16INT8: 1
};

/**
 * @enum {string}
 */
TFLITE.FullyConnectedOptionsWeightsFormatName = {
  '0': 'DEFAULT',
  '1': 'SHUFFLED4x16INT8'
};

/**
 * @enum {number}
 */
TFLITE.LSTMKernelType = {
  FULL: 0,
  BASIC: 1
};

/**
 * @enum {string}
 */
TFLITE.LSTMKernelTypeName = {
  '0': 'FULL',
  '1': 'BASIC'
};

/**
 * @enum {number}
 */
TFLITE.CombinerType = {
  SUM: 0,
  MEAN: 1,
  SQRTN: 2
};

/**
 * @enum {string}
 */
TFLITE.CombinerTypeName = {
  '0': 'SUM',
  '1': 'MEAN',
  '2': 'SQRTN'
};

/**
 * @enum {number}
 */
TFLITE.MirrorPadMode = {
  REFLECT: 0,
  SYMMETRIC: 1
};

/**
 * @enum {string}
 */
TFLITE.MirrorPadModeName = {
  '0': 'REFLECT',
  '1': 'SYMMETRIC'
};

/**
 * @enum {number}
 */
TFLITE.CustomOptionsFormat = {
  FLEXBUFFERS: 0
};

/**
 * @enum {string}
 */
TFLITE.CustomOptionsFormatName = {
  '0': 'FLEXBUFFERS'
};

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.CustomQuantization.prototype.custom = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

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

/**
 * @returns {Uint8Array}
 */
TFLITE.CustomQuantization.prototype.customArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  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 {flatbuffers.Builder} builder
 */
TFLITE.CustomQuantization.startCustomQuantization = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} customOffset
 */
TFLITE.CustomQuantization.addCustom = function(builder, customOffset) {
  builder.addFieldOffset(0, customOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.CustomQuantization.createCustomVector = 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
 */
TFLITE.CustomQuantization.startCustomVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.CustomQuantization.endCustomQuantization = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} customOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.CustomQuantization.createCustomQuantization = function(builder, customOffset) {
  TFLITE.CustomQuantization.startCustomQuantization(builder);
  TFLITE.CustomQuantization.addCustom(builder, customOffset);
  return TFLITE.CustomQuantization.endCustomQuantization(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.QuantizationParameters.prototype.min = 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}
 */
TFLITE.QuantizationParameters.prototype.minLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
TFLITE.QuantizationParameters.prototype.minArray = 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}
 */
TFLITE.QuantizationParameters.prototype.max = 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}
 */
TFLITE.QuantizationParameters.prototype.maxLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
TFLITE.QuantizationParameters.prototype.maxArray = 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}
 */
TFLITE.QuantizationParameters.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}
 */
TFLITE.QuantizationParameters.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}
 */
TFLITE.QuantizationParameters.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 {flatbuffers.Long}
 */
TFLITE.QuantizationParameters.prototype.zeroPoint = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
};

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

/**
 * @returns {TFLITE.QuantizationDetails}
 */
TFLITE.QuantizationParameters.prototype.detailsType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {TFLITE.QuantizationDetails} */ (this.bb.readUint8(this.bb_pos + offset)) : TFLITE.QuantizationDetails.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
TFLITE.QuantizationParameters.prototype.details = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.QuantizationParameters.startQuantizationParameters = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} minOffset
 */
TFLITE.QuantizationParameters.addMin = function(builder, minOffset) {
  builder.addFieldOffset(0, minOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.createMinVector = 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
 */
TFLITE.QuantizationParameters.startMinVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} maxOffset
 */
TFLITE.QuantizationParameters.addMax = function(builder, maxOffset) {
  builder.addFieldOffset(1, maxOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.createMaxVector = 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
 */
TFLITE.QuantizationParameters.startMaxVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.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
 */
TFLITE.QuantizationParameters.startScaleVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} zeroPointOffset
 */
TFLITE.QuantizationParameters.addZeroPoint = function(builder, zeroPointOffset) {
  builder.addFieldOffset(3, zeroPointOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Long>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.createZeroPointVector = 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
 */
TFLITE.QuantizationParameters.startZeroPointVector = function(builder, numElems) {
  builder.startVector(8, numElems, 8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.QuantizationDetails} detailsType
 */
TFLITE.QuantizationParameters.addDetailsType = function(builder, detailsType) {
  builder.addFieldInt8(4, detailsType, TFLITE.QuantizationDetails.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} detailsOffset
 */
TFLITE.QuantizationParameters.addDetails = function(builder, detailsOffset) {
  builder.addFieldOffset(5, detailsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantizedDimension
 */
TFLITE.QuantizationParameters.addQuantizedDimension = function(builder, quantizedDimension) {
  builder.addFieldInt32(6, quantizedDimension, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.endQuantizationParameters = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} minOffset
 * @param {flatbuffers.Offset} maxOffset
 * @param {flatbuffers.Offset} scaleOffset
 * @param {flatbuffers.Offset} zeroPointOffset
 * @param {TFLITE.QuantizationDetails} detailsType
 * @param {flatbuffers.Offset} detailsOffset
 * @param {number} quantizedDimension
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizationParameters.createQuantizationParameters = function(builder, minOffset, maxOffset, scaleOffset, zeroPointOffset, detailsType, detailsOffset, quantizedDimension) {
  TFLITE.QuantizationParameters.startQuantizationParameters(builder);
  TFLITE.QuantizationParameters.addMin(builder, minOffset);
  TFLITE.QuantizationParameters.addMax(builder, maxOffset);
  TFLITE.QuantizationParameters.addScale(builder, scaleOffset);
  TFLITE.QuantizationParameters.addZeroPoint(builder, zeroPointOffset);
  TFLITE.QuantizationParameters.addDetailsType(builder, detailsType);
  TFLITE.QuantizationParameters.addDetails(builder, detailsOffset);
  TFLITE.QuantizationParameters.addQuantizedDimension(builder, quantizedDimension);
  return TFLITE.QuantizationParameters.endQuantizationParameters(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Int32Vector.prototype.values = 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}
 */
TFLITE.Int32Vector.prototype.valuesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Int32Vector.prototype.valuesArray = 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
 */
TFLITE.Int32Vector.startInt32Vector = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 */
TFLITE.Int32Vector.addValues = function(builder, valuesOffset) {
  builder.addFieldOffset(0, valuesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Int32Vector.createValuesVector = 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
 */
TFLITE.Int32Vector.startValuesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Int32Vector.endInt32Vector = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Int32Vector.createInt32Vector = function(builder, valuesOffset) {
  TFLITE.Int32Vector.startInt32Vector(builder);
  TFLITE.Int32Vector.addValues(builder, valuesOffset);
  return TFLITE.Int32Vector.endInt32Vector(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Uint16Vector.prototype.values = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint16(this.bb.__vector(this.bb_pos + offset) + index * 2) : 0;
};

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

/**
 * @returns {Uint16Array}
 */
TFLITE.Uint16Vector.prototype.valuesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Uint16Array(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
 */
TFLITE.Uint16Vector.startUint16Vector = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 */
TFLITE.Uint16Vector.addValues = function(builder, valuesOffset) {
  builder.addFieldOffset(0, valuesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint16Vector.createValuesVector = function(builder, data) {
  builder.startVector(2, data.length, 2);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt16(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
TFLITE.Uint16Vector.startValuesVector = function(builder, numElems) {
  builder.startVector(2, numElems, 2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint16Vector.endUint16Vector = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint16Vector.createUint16Vector = function(builder, valuesOffset) {
  TFLITE.Uint16Vector.startUint16Vector(builder);
  TFLITE.Uint16Vector.addValues(builder, valuesOffset);
  return TFLITE.Uint16Vector.endUint16Vector(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Uint8Vector.prototype.values = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

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

/**
 * @returns {Uint8Array}
 */
TFLITE.Uint8Vector.prototype.valuesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  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 {flatbuffers.Builder} builder
 */
TFLITE.Uint8Vector.startUint8Vector = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 */
TFLITE.Uint8Vector.addValues = function(builder, valuesOffset) {
  builder.addFieldOffset(0, valuesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint8Vector.createValuesVector = 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
 */
TFLITE.Uint8Vector.startValuesVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint8Vector.endUint8Vector = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} valuesOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Uint8Vector.createUint8Vector = function(builder, valuesOffset) {
  TFLITE.Uint8Vector.startUint8Vector(builder);
  TFLITE.Uint8Vector.addValues(builder, valuesOffset);
  return TFLITE.Uint8Vector.endUint8Vector(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.DimensionType}
 */
TFLITE.DimensionMetadata.prototype.format = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.DimensionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.DimensionType.DENSE;
};

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

/**
 * @returns {TFLITE.SparseIndexVector}
 */
TFLITE.DimensionMetadata.prototype.arraySegmentsType = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {TFLITE.SparseIndexVector} */ (this.bb.readUint8(this.bb_pos + offset)) : TFLITE.SparseIndexVector.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
TFLITE.DimensionMetadata.prototype.arraySegments = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @returns {TFLITE.SparseIndexVector}
 */
TFLITE.DimensionMetadata.prototype.arrayIndicesType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {TFLITE.SparseIndexVector} */ (this.bb.readUint8(this.bb_pos + offset)) : TFLITE.SparseIndexVector.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
TFLITE.DimensionMetadata.prototype.arrayIndices = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.DimensionMetadata.startDimensionMetadata = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.DimensionType} format
 */
TFLITE.DimensionMetadata.addFormat = function(builder, format) {
  builder.addFieldInt8(0, format, TFLITE.DimensionType.DENSE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} denseSize
 */
TFLITE.DimensionMetadata.addDenseSize = function(builder, denseSize) {
  builder.addFieldInt32(1, denseSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.SparseIndexVector} arraySegmentsType
 */
TFLITE.DimensionMetadata.addArraySegmentsType = function(builder, arraySegmentsType) {
  builder.addFieldInt8(2, arraySegmentsType, TFLITE.SparseIndexVector.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} arraySegmentsOffset
 */
TFLITE.DimensionMetadata.addArraySegments = function(builder, arraySegmentsOffset) {
  builder.addFieldOffset(3, arraySegmentsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.SparseIndexVector} arrayIndicesType
 */
TFLITE.DimensionMetadata.addArrayIndicesType = function(builder, arrayIndicesType) {
  builder.addFieldInt8(4, arrayIndicesType, TFLITE.SparseIndexVector.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} arrayIndicesOffset
 */
TFLITE.DimensionMetadata.addArrayIndices = function(builder, arrayIndicesOffset) {
  builder.addFieldOffset(5, arrayIndicesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DimensionMetadata.endDimensionMetadata = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.DimensionType} format
 * @param {number} denseSize
 * @param {TFLITE.SparseIndexVector} arraySegmentsType
 * @param {flatbuffers.Offset} arraySegmentsOffset
 * @param {TFLITE.SparseIndexVector} arrayIndicesType
 * @param {flatbuffers.Offset} arrayIndicesOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.DimensionMetadata.createDimensionMetadata = function(builder, format, denseSize, arraySegmentsType, arraySegmentsOffset, arrayIndicesType, arrayIndicesOffset) {
  TFLITE.DimensionMetadata.startDimensionMetadata(builder);
  TFLITE.DimensionMetadata.addFormat(builder, format);
  TFLITE.DimensionMetadata.addDenseSize(builder, denseSize);
  TFLITE.DimensionMetadata.addArraySegmentsType(builder, arraySegmentsType);
  TFLITE.DimensionMetadata.addArraySegments(builder, arraySegmentsOffset);
  TFLITE.DimensionMetadata.addArrayIndicesType(builder, arrayIndicesType);
  TFLITE.DimensionMetadata.addArrayIndices(builder, arrayIndicesOffset);
  return TFLITE.DimensionMetadata.endDimensionMetadata(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.SparsityParameters.prototype.traversalOrder = 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}
 */
TFLITE.SparsityParameters.prototype.traversalOrderLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.SparsityParameters.prototype.traversalOrderArray = 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}
 */
TFLITE.SparsityParameters.prototype.blockMap = 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}
 */
TFLITE.SparsityParameters.prototype.blockMapLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.SparsityParameters.prototype.blockMapArray = 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
 * @param {TFLITE.DimensionMetadata=} obj
 * @returns {TFLITE.DimensionMetadata}
 */
TFLITE.SparsityParameters.prototype.dimMetadata = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new TFLITE.DimensionMetadata).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SparsityParameters.startSparsityParameters = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} traversalOrderOffset
 */
TFLITE.SparsityParameters.addTraversalOrder = function(builder, traversalOrderOffset) {
  builder.addFieldOffset(0, traversalOrderOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparsityParameters.createTraversalOrderVector = 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
 */
TFLITE.SparsityParameters.startTraversalOrderVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockMapOffset
 */
TFLITE.SparsityParameters.addBlockMap = function(builder, blockMapOffset) {
  builder.addFieldOffset(1, blockMapOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparsityParameters.createBlockMapVector = 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
 */
TFLITE.SparsityParameters.startBlockMapVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimMetadataOffset
 */
TFLITE.SparsityParameters.addDimMetadata = function(builder, dimMetadataOffset) {
  builder.addFieldOffset(2, dimMetadataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparsityParameters.createDimMetadataVector = 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
 */
TFLITE.SparsityParameters.startDimMetadataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparsityParameters.endSparsityParameters = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} traversalOrderOffset
 * @param {flatbuffers.Offset} blockMapOffset
 * @param {flatbuffers.Offset} dimMetadataOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparsityParameters.createSparsityParameters = function(builder, traversalOrderOffset, blockMapOffset, dimMetadataOffset) {
  TFLITE.SparsityParameters.startSparsityParameters(builder);
  TFLITE.SparsityParameters.addTraversalOrder(builder, traversalOrderOffset);
  TFLITE.SparsityParameters.addBlockMap(builder, blockMapOffset);
  TFLITE.SparsityParameters.addDimMetadata(builder, dimMetadataOffset);
  return TFLITE.SparsityParameters.endSparsityParameters(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Tensor.prototype.shape = 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}
 */
TFLITE.Tensor.prototype.shapeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Tensor.prototype.shapeArray = 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 {TFLITE.TensorType}
 */
TFLITE.Tensor.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @returns {number}
 */
TFLITE.Tensor.prototype.buffer = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
TFLITE.Tensor.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 {TFLITE.QuantizationParameters=} obj
 * @returns {TFLITE.QuantizationParameters|null}
 */
TFLITE.Tensor.prototype.quantization = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new TFLITE.QuantizationParameters).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {boolean}
 */
TFLITE.Tensor.prototype.isVariable = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Tensor.prototype.shapeSignature = 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}
 */
TFLITE.Tensor.prototype.shapeSignatureLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Tensor.prototype.shapeSignatureArray = 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;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.Tensor.startTensor = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} shapeOffset
 */
TFLITE.Tensor.addShape = function(builder, shapeOffset) {
  builder.addFieldOffset(0, shapeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Tensor.createShapeVector = 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
 */
TFLITE.Tensor.startShapeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} type
 */
TFLITE.Tensor.addType = function(builder, type) {
  builder.addFieldInt8(1, type, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} buffer
 */
TFLITE.Tensor.addBuffer = function(builder, buffer) {
  builder.addFieldInt32(2, buffer, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
TFLITE.Tensor.addName = function(builder, nameOffset) {
  builder.addFieldOffset(3, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} quantizationOffset
 */
TFLITE.Tensor.addQuantization = function(builder, quantizationOffset) {
  builder.addFieldOffset(4, quantizationOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} isVariable
 */
TFLITE.Tensor.addIsVariable = function(builder, isVariable) {
  builder.addFieldInt8(5, +isVariable, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sparsityOffset
 */
TFLITE.Tensor.addSparsity = function(builder, sparsityOffset) {
  builder.addFieldOffset(6, sparsityOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} shapeSignatureOffset
 */
TFLITE.Tensor.addShapeSignature = function(builder, shapeSignatureOffset) {
  builder.addFieldOffset(7, shapeSignatureOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Tensor.createShapeSignatureVector = 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
 */
TFLITE.Tensor.startShapeSignatureVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Tensor.endTensor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} shapeOffset
 * @param {TFLITE.TensorType} type
 * @param {number} buffer
 * @param {flatbuffers.Offset} nameOffset
 * @param {flatbuffers.Offset} quantizationOffset
 * @param {boolean} isVariable
 * @param {flatbuffers.Offset} sparsityOffset
 * @param {flatbuffers.Offset} shapeSignatureOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Tensor.createTensor = function(builder, shapeOffset, type, buffer, nameOffset, quantizationOffset, isVariable, sparsityOffset, shapeSignatureOffset) {
  TFLITE.Tensor.startTensor(builder);
  TFLITE.Tensor.addShape(builder, shapeOffset);
  TFLITE.Tensor.addType(builder, type);
  TFLITE.Tensor.addBuffer(builder, buffer);
  TFLITE.Tensor.addName(builder, nameOffset);
  TFLITE.Tensor.addQuantization(builder, quantizationOffset);
  TFLITE.Tensor.addIsVariable(builder, isVariable);
  TFLITE.Tensor.addSparsity(builder, sparsityOffset);
  TFLITE.Tensor.addShapeSignature(builder, shapeSignatureOffset);
  return TFLITE.Tensor.endTensor(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.Padding}
 */
TFLITE.Conv2DOptions.prototype.padding = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.Padding} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.Padding.SAME;
};

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.Conv2DOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.Conv2DOptions.startConv2DOptions = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 */
TFLITE.Conv2DOptions.addPadding = function(builder, padding) {
  builder.addFieldInt8(0, padding, TFLITE.Padding.SAME);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideW
 */
TFLITE.Conv2DOptions.addStrideW = function(builder, strideW) {
  builder.addFieldInt32(1, strideW, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideH
 */
TFLITE.Conv2DOptions.addStrideH = function(builder, strideH) {
  builder.addFieldInt32(2, strideH, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.Conv2DOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(3, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationWFactor
 */
TFLITE.Conv2DOptions.addDilationWFactor = function(builder, dilationWFactor) {
  builder.addFieldInt32(4, dilationWFactor, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationHFactor
 */
TFLITE.Conv2DOptions.addDilationHFactor = function(builder, dilationHFactor) {
  builder.addFieldInt32(5, dilationHFactor, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Conv2DOptions.endConv2DOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 * @param {number} strideW
 * @param {number} strideH
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {number} dilationWFactor
 * @param {number} dilationHFactor
 * @returns {flatbuffers.Offset}
 */
TFLITE.Conv2DOptions.createConv2DOptions = function(builder, padding, strideW, strideH, fusedActivationFunction, dilationWFactor, dilationHFactor) {
  TFLITE.Conv2DOptions.startConv2DOptions(builder);
  TFLITE.Conv2DOptions.addPadding(builder, padding);
  TFLITE.Conv2DOptions.addStrideW(builder, strideW);
  TFLITE.Conv2DOptions.addStrideH(builder, strideH);
  TFLITE.Conv2DOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.Conv2DOptions.addDilationWFactor(builder, dilationWFactor);
  TFLITE.Conv2DOptions.addDilationHFactor(builder, dilationHFactor);
  return TFLITE.Conv2DOptions.endConv2DOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.Padding}
 */
TFLITE.Pool2DOptions.prototype.padding = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.Padding} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.Padding.SAME;
};

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.Pool2DOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.Pool2DOptions.startPool2DOptions = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 */
TFLITE.Pool2DOptions.addPadding = function(builder, padding) {
  builder.addFieldInt8(0, padding, TFLITE.Padding.SAME);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideW
 */
TFLITE.Pool2DOptions.addStrideW = function(builder, strideW) {
  builder.addFieldInt32(1, strideW, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideH
 */
TFLITE.Pool2DOptions.addStrideH = function(builder, strideH) {
  builder.addFieldInt32(2, strideH, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} filterWidth
 */
TFLITE.Pool2DOptions.addFilterWidth = function(builder, filterWidth) {
  builder.addFieldInt32(3, filterWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} filterHeight
 */
TFLITE.Pool2DOptions.addFilterHeight = function(builder, filterHeight) {
  builder.addFieldInt32(4, filterHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.Pool2DOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(5, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Pool2DOptions.endPool2DOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 * @param {number} strideW
 * @param {number} strideH
 * @param {number} filterWidth
 * @param {number} filterHeight
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.Pool2DOptions.createPool2DOptions = function(builder, padding, strideW, strideH, filterWidth, filterHeight, fusedActivationFunction) {
  TFLITE.Pool2DOptions.startPool2DOptions(builder);
  TFLITE.Pool2DOptions.addPadding(builder, padding);
  TFLITE.Pool2DOptions.addStrideW(builder, strideW);
  TFLITE.Pool2DOptions.addStrideH(builder, strideH);
  TFLITE.Pool2DOptions.addFilterWidth(builder, filterWidth);
  TFLITE.Pool2DOptions.addFilterHeight(builder, filterHeight);
  TFLITE.Pool2DOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.Pool2DOptions.endPool2DOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.Padding}
 */
TFLITE.DepthwiseConv2DOptions.prototype.padding = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.Padding} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.Padding.SAME;
};

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.DepthwiseConv2DOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.DepthwiseConv2DOptions.startDepthwiseConv2DOptions = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 */
TFLITE.DepthwiseConv2DOptions.addPadding = function(builder, padding) {
  builder.addFieldInt8(0, padding, TFLITE.Padding.SAME);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideW
 */
TFLITE.DepthwiseConv2DOptions.addStrideW = function(builder, strideW) {
  builder.addFieldInt32(1, strideW, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideH
 */
TFLITE.DepthwiseConv2DOptions.addStrideH = function(builder, strideH) {
  builder.addFieldInt32(2, strideH, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} depthMultiplier
 */
TFLITE.DepthwiseConv2DOptions.addDepthMultiplier = function(builder, depthMultiplier) {
  builder.addFieldInt32(3, depthMultiplier, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.DepthwiseConv2DOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(4, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationWFactor
 */
TFLITE.DepthwiseConv2DOptions.addDilationWFactor = function(builder, dilationWFactor) {
  builder.addFieldInt32(5, dilationWFactor, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationHFactor
 */
TFLITE.DepthwiseConv2DOptions.addDilationHFactor = function(builder, dilationHFactor) {
  builder.addFieldInt32(6, dilationHFactor, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DepthwiseConv2DOptions.endDepthwiseConv2DOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 * @param {number} strideW
 * @param {number} strideH
 * @param {number} depthMultiplier
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {number} dilationWFactor
 * @param {number} dilationHFactor
 * @returns {flatbuffers.Offset}
 */
TFLITE.DepthwiseConv2DOptions.createDepthwiseConv2DOptions = function(builder, padding, strideW, strideH, depthMultiplier, fusedActivationFunction, dilationWFactor, dilationHFactor) {
  TFLITE.DepthwiseConv2DOptions.startDepthwiseConv2DOptions(builder);
  TFLITE.DepthwiseConv2DOptions.addPadding(builder, padding);
  TFLITE.DepthwiseConv2DOptions.addStrideW(builder, strideW);
  TFLITE.DepthwiseConv2DOptions.addStrideH(builder, strideH);
  TFLITE.DepthwiseConv2DOptions.addDepthMultiplier(builder, depthMultiplier);
  TFLITE.DepthwiseConv2DOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.DepthwiseConv2DOptions.addDilationWFactor(builder, dilationWFactor);
  TFLITE.DepthwiseConv2DOptions.addDilationHFactor(builder, dilationHFactor);
  return TFLITE.DepthwiseConv2DOptions.endDepthwiseConv2DOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.numChannels = 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}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.numColumnsPerChannel = 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}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.numColumnsPerChannelLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.numColumnsPerChannelArray = 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}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.embeddingDimPerChannel = 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}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.embeddingDimPerChannelLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.ConcatEmbeddingsOptions.prototype.embeddingDimPerChannelArray = 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 {flatbuffers.Builder} builder
 */
TFLITE.ConcatEmbeddingsOptions.startConcatEmbeddingsOptions = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numChannels
 */
TFLITE.ConcatEmbeddingsOptions.addNumChannels = function(builder, numChannels) {
  builder.addFieldInt32(0, numChannels, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} numColumnsPerChannelOffset
 */
TFLITE.ConcatEmbeddingsOptions.addNumColumnsPerChannel = function(builder, numColumnsPerChannelOffset) {
  builder.addFieldOffset(1, numColumnsPerChannelOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatEmbeddingsOptions.createNumColumnsPerChannelVector = 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
 */
TFLITE.ConcatEmbeddingsOptions.startNumColumnsPerChannelVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} embeddingDimPerChannelOffset
 */
TFLITE.ConcatEmbeddingsOptions.addEmbeddingDimPerChannel = function(builder, embeddingDimPerChannelOffset) {
  builder.addFieldOffset(2, embeddingDimPerChannelOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatEmbeddingsOptions.createEmbeddingDimPerChannelVector = 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
 */
TFLITE.ConcatEmbeddingsOptions.startEmbeddingDimPerChannelVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatEmbeddingsOptions.endConcatEmbeddingsOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numChannels
 * @param {flatbuffers.Offset} numColumnsPerChannelOffset
 * @param {flatbuffers.Offset} embeddingDimPerChannelOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatEmbeddingsOptions.createConcatEmbeddingsOptions = function(builder, numChannels, numColumnsPerChannelOffset, embeddingDimPerChannelOffset) {
  TFLITE.ConcatEmbeddingsOptions.startConcatEmbeddingsOptions(builder);
  TFLITE.ConcatEmbeddingsOptions.addNumChannels(builder, numChannels);
  TFLITE.ConcatEmbeddingsOptions.addNumColumnsPerChannel(builder, numColumnsPerChannelOffset);
  TFLITE.ConcatEmbeddingsOptions.addEmbeddingDimPerChannel(builder, embeddingDimPerChannelOffset);
  return TFLITE.ConcatEmbeddingsOptions.endConcatEmbeddingsOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.LSHProjectionType}
 */
TFLITE.LSHProjectionOptions.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.LSHProjectionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.LSHProjectionType.UNKNOWN;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LSHProjectionOptions.startLSHProjectionOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.LSHProjectionType} type
 */
TFLITE.LSHProjectionOptions.addType = function(builder, type) {
  builder.addFieldInt8(0, type, TFLITE.LSHProjectionType.UNKNOWN);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LSHProjectionOptions.endLSHProjectionOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.LSHProjectionType} type
 * @returns {flatbuffers.Offset}
 */
TFLITE.LSHProjectionOptions.createLSHProjectionOptions = function(builder, type) {
  TFLITE.LSHProjectionOptions.startLSHProjectionOptions(builder);
  TFLITE.LSHProjectionOptions.addType(builder, type);
  return TFLITE.LSHProjectionOptions.endLSHProjectionOptions(builder);
}

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

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.SVDFOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SVDFOptions.startSVDFOptions = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} rank
 */
TFLITE.SVDFOptions.addRank = function(builder, rank) {
  builder.addFieldInt32(0, rank, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.SVDFOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(1, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.SVDFOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(2, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SVDFOptions.endSVDFOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} rank
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.SVDFOptions.createSVDFOptions = function(builder, rank, fusedActivationFunction, asymmetricQuantizeInputs) {
  TFLITE.SVDFOptions.startSVDFOptions(builder);
  TFLITE.SVDFOptions.addRank(builder, rank);
  TFLITE.SVDFOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.SVDFOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.SVDFOptions.endSVDFOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.RNNOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @returns {boolean}
 */
TFLITE.RNNOptions.prototype.asymmetricQuantizeInputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.RNNOptions.startRNNOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.RNNOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.RNNOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(1, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.RNNOptions.endRNNOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.RNNOptions.createRNNOptions = function(builder, fusedActivationFunction, asymmetricQuantizeInputs) {
  TFLITE.RNNOptions.startRNNOptions(builder);
  TFLITE.RNNOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.RNNOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.RNNOptions.endRNNOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.SequenceRNNOptions.prototype.timeMajor = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.SequenceRNNOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SequenceRNNOptions.startSequenceRNNOptions = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 */
TFLITE.SequenceRNNOptions.addTimeMajor = function(builder, timeMajor) {
  builder.addFieldInt8(0, +timeMajor, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.SequenceRNNOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(1, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.SequenceRNNOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(2, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SequenceRNNOptions.endSequenceRNNOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.SequenceRNNOptions.createSequenceRNNOptions = function(builder, timeMajor, fusedActivationFunction, asymmetricQuantizeInputs) {
  TFLITE.SequenceRNNOptions.startSequenceRNNOptions(builder);
  TFLITE.SequenceRNNOptions.addTimeMajor(builder, timeMajor);
  TFLITE.SequenceRNNOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.SequenceRNNOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.SequenceRNNOptions.endSequenceRNNOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.BidirectionalSequenceRNNOptions.prototype.timeMajor = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.BidirectionalSequenceRNNOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.BidirectionalSequenceRNNOptions.startBidirectionalSequenceRNNOptions = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 */
TFLITE.BidirectionalSequenceRNNOptions.addTimeMajor = function(builder, timeMajor) {
  builder.addFieldInt8(0, +timeMajor, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.BidirectionalSequenceRNNOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(1, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} mergeOutputs
 */
TFLITE.BidirectionalSequenceRNNOptions.addMergeOutputs = function(builder, mergeOutputs) {
  builder.addFieldInt8(2, +mergeOutputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.BidirectionalSequenceRNNOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(3, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.BidirectionalSequenceRNNOptions.endBidirectionalSequenceRNNOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {boolean} mergeOutputs
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.BidirectionalSequenceRNNOptions.createBidirectionalSequenceRNNOptions = function(builder, timeMajor, fusedActivationFunction, mergeOutputs, asymmetricQuantizeInputs) {
  TFLITE.BidirectionalSequenceRNNOptions.startBidirectionalSequenceRNNOptions(builder);
  TFLITE.BidirectionalSequenceRNNOptions.addTimeMajor(builder, timeMajor);
  TFLITE.BidirectionalSequenceRNNOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.BidirectionalSequenceRNNOptions.addMergeOutputs(builder, mergeOutputs);
  TFLITE.BidirectionalSequenceRNNOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.BidirectionalSequenceRNNOptions.endBidirectionalSequenceRNNOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.FullyConnectedOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @returns {TFLITE.FullyConnectedOptionsWeightsFormat}
 */
TFLITE.FullyConnectedOptions.prototype.weightsFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.FullyConnectedOptionsWeightsFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.FullyConnectedOptionsWeightsFormat.DEFAULT;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.FullyConnectedOptions.startFullyConnectedOptions = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.FullyConnectedOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.FullyConnectedOptionsWeightsFormat} weightsFormat
 */
TFLITE.FullyConnectedOptions.addWeightsFormat = function(builder, weightsFormat) {
  builder.addFieldInt8(1, weightsFormat, TFLITE.FullyConnectedOptionsWeightsFormat.DEFAULT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepNumDims
 */
TFLITE.FullyConnectedOptions.addKeepNumDims = function(builder, keepNumDims) {
  builder.addFieldInt8(2, +keepNumDims, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.FullyConnectedOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(3, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FullyConnectedOptions.endFullyConnectedOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {TFLITE.FullyConnectedOptionsWeightsFormat} weightsFormat
 * @param {boolean} keepNumDims
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.FullyConnectedOptions.createFullyConnectedOptions = function(builder, fusedActivationFunction, weightsFormat, keepNumDims, asymmetricQuantizeInputs) {
  TFLITE.FullyConnectedOptions.startFullyConnectedOptions(builder);
  TFLITE.FullyConnectedOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.FullyConnectedOptions.addWeightsFormat(builder, weightsFormat);
  TFLITE.FullyConnectedOptions.addKeepNumDims(builder, keepNumDims);
  TFLITE.FullyConnectedOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.FullyConnectedOptions.endFullyConnectedOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.SoftmaxOptions.prototype.beta = 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
 */
TFLITE.SoftmaxOptions.startSoftmaxOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
TFLITE.SoftmaxOptions.addBeta = function(builder, beta) {
  builder.addFieldFloat32(0, beta, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SoftmaxOptions.endSoftmaxOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 * @returns {flatbuffers.Offset}
 */
TFLITE.SoftmaxOptions.createSoftmaxOptions = function(builder, beta) {
  TFLITE.SoftmaxOptions.startSoftmaxOptions(builder);
  TFLITE.SoftmaxOptions.addBeta(builder, beta);
  return TFLITE.SoftmaxOptions.endSoftmaxOptions(builder);
}

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

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.ConcatenationOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ConcatenationOptions.startConcatenationOptions = function(builder) {
  builder.startObject(2);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.ConcatenationOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(1, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatenationOptions.endConcatenationOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.ConcatenationOptions.createConcatenationOptions = function(builder, axis, fusedActivationFunction) {
  TFLITE.ConcatenationOptions.startConcatenationOptions(builder);
  TFLITE.ConcatenationOptions.addAxis(builder, axis);
  TFLITE.ConcatenationOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.ConcatenationOptions.endConcatenationOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.AddOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.AddOptions.startAddOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.AddOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.AddOptions.endAddOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.AddOptions.createAddOptions = function(builder, fusedActivationFunction) {
  TFLITE.AddOptions.startAddOptions(builder);
  TFLITE.AddOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.AddOptions.endAddOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.MulOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.MulOptions.startMulOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.MulOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MulOptions.endMulOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.MulOptions.createMulOptions = function(builder, fusedActivationFunction) {
  TFLITE.MulOptions.startMulOptions(builder);
  TFLITE.MulOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.MulOptions.endMulOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.L2NormOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.L2NormOptions.startL2NormOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.L2NormOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.L2NormOptions.endL2NormOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.L2NormOptions.createL2NormOptions = function(builder, fusedActivationFunction) {
  TFLITE.L2NormOptions.startL2NormOptions(builder);
  TFLITE.L2NormOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.L2NormOptions.endL2NormOptions(builder);
}

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

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

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.LocalResponseNormalizationOptions.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}
 */
TFLITE.LocalResponseNormalizationOptions.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
 */
TFLITE.LocalResponseNormalizationOptions.startLocalResponseNormalizationOptions = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} radius
 */
TFLITE.LocalResponseNormalizationOptions.addRadius = function(builder, radius) {
  builder.addFieldInt32(0, radius, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} bias
 */
TFLITE.LocalResponseNormalizationOptions.addBias = function(builder, bias) {
  builder.addFieldFloat32(1, bias, 0.0);
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LocalResponseNormalizationOptions.endLocalResponseNormalizationOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} radius
 * @param {number} bias
 * @param {number} alpha
 * @param {number} beta
 * @returns {flatbuffers.Offset}
 */
TFLITE.LocalResponseNormalizationOptions.createLocalResponseNormalizationOptions = function(builder, radius, bias, alpha, beta) {
  TFLITE.LocalResponseNormalizationOptions.startLocalResponseNormalizationOptions(builder);
  TFLITE.LocalResponseNormalizationOptions.addRadius(builder, radius);
  TFLITE.LocalResponseNormalizationOptions.addBias(builder, bias);
  TFLITE.LocalResponseNormalizationOptions.addAlpha(builder, alpha);
  TFLITE.LocalResponseNormalizationOptions.addBeta(builder, beta);
  return TFLITE.LocalResponseNormalizationOptions.endLocalResponseNormalizationOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.LSTMOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

/**
 * @returns {TFLITE.LSTMKernelType}
 */
TFLITE.LSTMOptions.prototype.kernelType = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {TFLITE.LSTMKernelType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.LSTMKernelType.FULL;
};

/**
 * @returns {boolean}
 */
TFLITE.LSTMOptions.prototype.asymmetricQuantizeInputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LSTMOptions.startLSTMOptions = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.LSTMOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} cellClip
 */
TFLITE.LSTMOptions.addCellClip = function(builder, cellClip) {
  builder.addFieldFloat32(1, cellClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} projClip
 */
TFLITE.LSTMOptions.addProjClip = function(builder, projClip) {
  builder.addFieldFloat32(2, projClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.LSTMKernelType} kernelType
 */
TFLITE.LSTMOptions.addKernelType = function(builder, kernelType) {
  builder.addFieldInt8(3, kernelType, TFLITE.LSTMKernelType.FULL);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.LSTMOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(4, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LSTMOptions.endLSTMOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {number} cellClip
 * @param {number} projClip
 * @param {TFLITE.LSTMKernelType} kernelType
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.LSTMOptions.createLSTMOptions = function(builder, fusedActivationFunction, cellClip, projClip, kernelType, asymmetricQuantizeInputs) {
  TFLITE.LSTMOptions.startLSTMOptions(builder);
  TFLITE.LSTMOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.LSTMOptions.addCellClip(builder, cellClip);
  TFLITE.LSTMOptions.addProjClip(builder, projClip);
  TFLITE.LSTMOptions.addKernelType(builder, kernelType);
  TFLITE.LSTMOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.LSTMOptions.endLSTMOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.UnidirectionalSequenceLSTMOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.UnidirectionalSequenceLSTMOptions.prototype.asymmetricQuantizeInputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.UnidirectionalSequenceLSTMOptions.startUnidirectionalSequenceLSTMOptions = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.UnidirectionalSequenceLSTMOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} cellClip
 */
TFLITE.UnidirectionalSequenceLSTMOptions.addCellClip = function(builder, cellClip) {
  builder.addFieldFloat32(1, cellClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} projClip
 */
TFLITE.UnidirectionalSequenceLSTMOptions.addProjClip = function(builder, projClip) {
  builder.addFieldFloat32(2, projClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 */
TFLITE.UnidirectionalSequenceLSTMOptions.addTimeMajor = function(builder, timeMajor) {
  builder.addFieldInt8(3, +timeMajor, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.UnidirectionalSequenceLSTMOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(4, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.UnidirectionalSequenceLSTMOptions.endUnidirectionalSequenceLSTMOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {number} cellClip
 * @param {number} projClip
 * @param {boolean} timeMajor
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.UnidirectionalSequenceLSTMOptions.createUnidirectionalSequenceLSTMOptions = function(builder, fusedActivationFunction, cellClip, projClip, timeMajor, asymmetricQuantizeInputs) {
  TFLITE.UnidirectionalSequenceLSTMOptions.startUnidirectionalSequenceLSTMOptions(builder);
  TFLITE.UnidirectionalSequenceLSTMOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.UnidirectionalSequenceLSTMOptions.addCellClip(builder, cellClip);
  TFLITE.UnidirectionalSequenceLSTMOptions.addProjClip(builder, projClip);
  TFLITE.UnidirectionalSequenceLSTMOptions.addTimeMajor(builder, timeMajor);
  TFLITE.UnidirectionalSequenceLSTMOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.UnidirectionalSequenceLSTMOptions.endUnidirectionalSequenceLSTMOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.BidirectionalSequenceLSTMOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.BidirectionalSequenceLSTMOptions.prototype.timeMajor = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true;
};

/**
 * @returns {boolean}
 */
TFLITE.BidirectionalSequenceLSTMOptions.prototype.asymmetricQuantizeInputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.BidirectionalSequenceLSTMOptions.startBidirectionalSequenceLSTMOptions = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.BidirectionalSequenceLSTMOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} cellClip
 */
TFLITE.BidirectionalSequenceLSTMOptions.addCellClip = function(builder, cellClip) {
  builder.addFieldFloat32(1, cellClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} projClip
 */
TFLITE.BidirectionalSequenceLSTMOptions.addProjClip = function(builder, projClip) {
  builder.addFieldFloat32(2, projClip, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} mergeOutputs
 */
TFLITE.BidirectionalSequenceLSTMOptions.addMergeOutputs = function(builder, mergeOutputs) {
  builder.addFieldInt8(3, +mergeOutputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} timeMajor
 */
TFLITE.BidirectionalSequenceLSTMOptions.addTimeMajor = function(builder, timeMajor) {
  builder.addFieldInt8(4, +timeMajor, +true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} asymmetricQuantizeInputs
 */
TFLITE.BidirectionalSequenceLSTMOptions.addAsymmetricQuantizeInputs = function(builder, asymmetricQuantizeInputs) {
  builder.addFieldInt8(5, +asymmetricQuantizeInputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.BidirectionalSequenceLSTMOptions.endBidirectionalSequenceLSTMOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @param {number} cellClip
 * @param {number} projClip
 * @param {boolean} mergeOutputs
 * @param {boolean} timeMajor
 * @param {boolean} asymmetricQuantizeInputs
 * @returns {flatbuffers.Offset}
 */
TFLITE.BidirectionalSequenceLSTMOptions.createBidirectionalSequenceLSTMOptions = function(builder, fusedActivationFunction, cellClip, projClip, mergeOutputs, timeMajor, asymmetricQuantizeInputs) {
  TFLITE.BidirectionalSequenceLSTMOptions.startBidirectionalSequenceLSTMOptions(builder);
  TFLITE.BidirectionalSequenceLSTMOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  TFLITE.BidirectionalSequenceLSTMOptions.addCellClip(builder, cellClip);
  TFLITE.BidirectionalSequenceLSTMOptions.addProjClip(builder, projClip);
  TFLITE.BidirectionalSequenceLSTMOptions.addMergeOutputs(builder, mergeOutputs);
  TFLITE.BidirectionalSequenceLSTMOptions.addTimeMajor(builder, timeMajor);
  TFLITE.BidirectionalSequenceLSTMOptions.addAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs);
  return TFLITE.BidirectionalSequenceLSTMOptions.endBidirectionalSequenceLSTMOptions(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ResizeBilinearOptions.startResizeBilinearOptions = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} alignCorners
 */
TFLITE.ResizeBilinearOptions.addAlignCorners = function(builder, alignCorners) {
  builder.addFieldInt8(2, +alignCorners, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} halfPixelCenters
 */
TFLITE.ResizeBilinearOptions.addHalfPixelCenters = function(builder, halfPixelCenters) {
  builder.addFieldInt8(3, +halfPixelCenters, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ResizeBilinearOptions.endResizeBilinearOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} alignCorners
 * @param {boolean} halfPixelCenters
 * @returns {flatbuffers.Offset}
 */
TFLITE.ResizeBilinearOptions.createResizeBilinearOptions = function(builder, alignCorners, halfPixelCenters) {
  TFLITE.ResizeBilinearOptions.startResizeBilinearOptions(builder);
  TFLITE.ResizeBilinearOptions.addAlignCorners(builder, alignCorners);
  TFLITE.ResizeBilinearOptions.addHalfPixelCenters(builder, halfPixelCenters);
  return TFLITE.ResizeBilinearOptions.endResizeBilinearOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.ResizeNearestNeighborOptions.prototype.alignCorners = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ResizeNearestNeighborOptions.startResizeNearestNeighborOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} alignCorners
 */
TFLITE.ResizeNearestNeighborOptions.addAlignCorners = function(builder, alignCorners) {
  builder.addFieldInt8(0, +alignCorners, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ResizeNearestNeighborOptions.endResizeNearestNeighborOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} alignCorners
 * @returns {flatbuffers.Offset}
 */
TFLITE.ResizeNearestNeighborOptions.createResizeNearestNeighborOptions = function(builder, alignCorners) {
  TFLITE.ResizeNearestNeighborOptions.startResizeNearestNeighborOptions(builder);
  TFLITE.ResizeNearestNeighborOptions.addAlignCorners(builder, alignCorners);
  return TFLITE.ResizeNearestNeighborOptions.endResizeNearestNeighborOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.CallOptions.prototype.subgraph = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.CallOptions.startCallOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} subgraph
 */
TFLITE.CallOptions.addSubgraph = function(builder, subgraph) {
  builder.addFieldInt32(0, subgraph, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.CallOptions.endCallOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} subgraph
 * @returns {flatbuffers.Offset}
 */
TFLITE.CallOptions.createCallOptions = function(builder, subgraph) {
  TFLITE.CallOptions.startCallOptions(builder);
  TFLITE.CallOptions.addSubgraph(builder, subgraph);
  return TFLITE.CallOptions.endCallOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.PadOptions.startPadOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PadOptions.endPadOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PadOptions.createPadOptions = function(builder) {
  TFLITE.PadOptions.startPadOptions(builder);
  return TFLITE.PadOptions.endPadOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.PadV2Options.startPadV2Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PadV2Options.endPadV2Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PadV2Options.createPadV2Options = function(builder) {
  TFLITE.PadV2Options.startPadV2Options(builder);
  return TFLITE.PadV2Options.endPadV2Options(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.ReshapeOptions.prototype.newShape = 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}
 */
TFLITE.ReshapeOptions.prototype.newShapeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.ReshapeOptions.prototype.newShapeArray = 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
 */
TFLITE.ReshapeOptions.startReshapeOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} newShapeOffset
 */
TFLITE.ReshapeOptions.addNewShape = function(builder, newShapeOffset) {
  builder.addFieldOffset(0, newShapeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReshapeOptions.createNewShapeVector = 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
 */
TFLITE.ReshapeOptions.startNewShapeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReshapeOptions.endReshapeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} newShapeOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReshapeOptions.createReshapeOptions = function(builder, newShapeOffset) {
  TFLITE.ReshapeOptions.startReshapeOptions(builder);
  TFLITE.ReshapeOptions.addNewShape(builder, newShapeOffset);
  return TFLITE.ReshapeOptions.endReshapeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SpaceToBatchNDOptions.startSpaceToBatchNDOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SpaceToBatchNDOptions.endSpaceToBatchNDOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SpaceToBatchNDOptions.createSpaceToBatchNDOptions = function(builder) {
  TFLITE.SpaceToBatchNDOptions.startSpaceToBatchNDOptions(builder);
  return TFLITE.SpaceToBatchNDOptions.endSpaceToBatchNDOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.BatchToSpaceNDOptions.startBatchToSpaceNDOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.BatchToSpaceNDOptions.endBatchToSpaceNDOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.BatchToSpaceNDOptions.createBatchToSpaceNDOptions = function(builder) {
  TFLITE.BatchToSpaceNDOptions.startBatchToSpaceNDOptions(builder);
  return TFLITE.BatchToSpaceNDOptions.endBatchToSpaceNDOptions(builder);
}

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

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SkipGramOptions.startSkipGramOptions = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} ngramSize
 */
TFLITE.SkipGramOptions.addNgramSize = function(builder, ngramSize) {
  builder.addFieldInt32(0, ngramSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxSkipSize
 */
TFLITE.SkipGramOptions.addMaxSkipSize = function(builder, maxSkipSize) {
  builder.addFieldInt32(1, maxSkipSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} includeAllNgrams
 */
TFLITE.SkipGramOptions.addIncludeAllNgrams = function(builder, includeAllNgrams) {
  builder.addFieldInt8(2, +includeAllNgrams, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SkipGramOptions.endSkipGramOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} ngramSize
 * @param {number} maxSkipSize
 * @param {boolean} includeAllNgrams
 * @returns {flatbuffers.Offset}
 */
TFLITE.SkipGramOptions.createSkipGramOptions = function(builder, ngramSize, maxSkipSize, includeAllNgrams) {
  TFLITE.SkipGramOptions.startSkipGramOptions(builder);
  TFLITE.SkipGramOptions.addNgramSize(builder, ngramSize);
  TFLITE.SkipGramOptions.addMaxSkipSize(builder, maxSkipSize);
  TFLITE.SkipGramOptions.addIncludeAllNgrams(builder, includeAllNgrams);
  return TFLITE.SkipGramOptions.endSkipGramOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.SpaceToDepthOptions.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
 */
TFLITE.SpaceToDepthOptions.startSpaceToDepthOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 */
TFLITE.SpaceToDepthOptions.addBlockSize = function(builder, blockSize) {
  builder.addFieldInt32(0, blockSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SpaceToDepthOptions.endSpaceToDepthOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 * @returns {flatbuffers.Offset}
 */
TFLITE.SpaceToDepthOptions.createSpaceToDepthOptions = function(builder, blockSize) {
  TFLITE.SpaceToDepthOptions.startSpaceToDepthOptions(builder);
  TFLITE.SpaceToDepthOptions.addBlockSize(builder, blockSize);
  return TFLITE.SpaceToDepthOptions.endSpaceToDepthOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.DepthToSpaceOptions.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
 */
TFLITE.DepthToSpaceOptions.startDepthToSpaceOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 */
TFLITE.DepthToSpaceOptions.addBlockSize = function(builder, blockSize) {
  builder.addFieldInt32(0, blockSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DepthToSpaceOptions.endDepthToSpaceOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 * @returns {flatbuffers.Offset}
 */
TFLITE.DepthToSpaceOptions.createDepthToSpaceOptions = function(builder, blockSize) {
  TFLITE.DepthToSpaceOptions.startDepthToSpaceOptions(builder);
  TFLITE.DepthToSpaceOptions.addBlockSize(builder, blockSize);
  return TFLITE.DepthToSpaceOptions.endDepthToSpaceOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.SubOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SubOptions.startSubOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.SubOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubOptions.endSubOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubOptions.createSubOptions = function(builder, fusedActivationFunction) {
  TFLITE.SubOptions.startSubOptions(builder);
  TFLITE.SubOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.SubOptions.endSubOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.ActivationFunctionType}
 */
TFLITE.DivOptions.prototype.fusedActivationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.ActivationFunctionType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.ActivationFunctionType.NONE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.DivOptions.startDivOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 */
TFLITE.DivOptions.addFusedActivationFunction = function(builder, fusedActivationFunction) {
  builder.addFieldInt8(0, fusedActivationFunction, TFLITE.ActivationFunctionType.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DivOptions.endDivOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.ActivationFunctionType} fusedActivationFunction
 * @returns {flatbuffers.Offset}
 */
TFLITE.DivOptions.createDivOptions = function(builder, fusedActivationFunction) {
  TFLITE.DivOptions.startDivOptions(builder);
  TFLITE.DivOptions.addFusedActivationFunction(builder, fusedActivationFunction);
  return TFLITE.DivOptions.endDivOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.TopKV2Options.startTopKV2Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TopKV2Options.endTopKV2Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TopKV2Options.createTopKV2Options = function(builder) {
  TFLITE.TopKV2Options.startTopKV2Options(builder);
  return TFLITE.TopKV2Options.endTopKV2Options(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.CombinerType}
 */
TFLITE.EmbeddingLookupSparseOptions.prototype.combiner = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.CombinerType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.CombinerType.SUM;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.EmbeddingLookupSparseOptions.startEmbeddingLookupSparseOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.CombinerType} combiner
 */
TFLITE.EmbeddingLookupSparseOptions.addCombiner = function(builder, combiner) {
  builder.addFieldInt8(0, combiner, TFLITE.CombinerType.SUM);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.EmbeddingLookupSparseOptions.endEmbeddingLookupSparseOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.CombinerType} combiner
 * @returns {flatbuffers.Offset}
 */
TFLITE.EmbeddingLookupSparseOptions.createEmbeddingLookupSparseOptions = function(builder, combiner) {
  TFLITE.EmbeddingLookupSparseOptions.startEmbeddingLookupSparseOptions(builder);
  TFLITE.EmbeddingLookupSparseOptions.addCombiner(builder, combiner);
  return TFLITE.EmbeddingLookupSparseOptions.endEmbeddingLookupSparseOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.GatherOptions.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
 */
TFLITE.GatherOptions.startGatherOptions = function(builder) {
  builder.startObject(1);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GatherOptions.endGatherOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
TFLITE.GatherOptions.createGatherOptions = function(builder, axis) {
  TFLITE.GatherOptions.startGatherOptions(builder);
  TFLITE.GatherOptions.addAxis(builder, axis);
  return TFLITE.GatherOptions.endGatherOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.TransposeOptions.startTransposeOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TransposeOptions.endTransposeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TransposeOptions.createTransposeOptions = function(builder) {
  TFLITE.TransposeOptions.startTransposeOptions(builder);
  return TFLITE.TransposeOptions.endTransposeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ExpOptions.startExpOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ExpOptions.endExpOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ExpOptions.createExpOptions = function(builder) {
  TFLITE.ExpOptions.startExpOptions(builder);
  return TFLITE.ExpOptions.endExpOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.CosOptions.startCosOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.CosOptions.endCosOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.CosOptions.createCosOptions = function(builder) {
  TFLITE.CosOptions.startCosOptions(builder);
  return TFLITE.CosOptions.endCosOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.ReducerOptions.prototype.keepDims = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ReducerOptions.startReducerOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 */
TFLITE.ReducerOptions.addKeepDims = function(builder, keepDims) {
  builder.addFieldInt8(0, +keepDims, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReducerOptions.endReducerOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReducerOptions.createReducerOptions = function(builder, keepDims) {
  TFLITE.ReducerOptions.startReducerOptions(builder);
  TFLITE.ReducerOptions.addKeepDims(builder, keepDims);
  return TFLITE.ReducerOptions.endReducerOptions(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.SqueezeOptions.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}
 */
TFLITE.SqueezeOptions.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}
 */
TFLITE.SqueezeOptions.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
 */
TFLITE.SqueezeOptions.startSqueezeOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} squeezeDimsOffset
 */
TFLITE.SqueezeOptions.addSqueezeDims = function(builder, squeezeDimsOffset) {
  builder.addFieldOffset(0, squeezeDimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SqueezeOptions.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
 */
TFLITE.SqueezeOptions.startSqueezeDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SqueezeOptions.endSqueezeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} squeezeDimsOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.SqueezeOptions.createSqueezeOptions = function(builder, squeezeDimsOffset) {
  TFLITE.SqueezeOptions.startSqueezeOptions(builder);
  TFLITE.SqueezeOptions.addSqueezeDims(builder, squeezeDimsOffset);
  return TFLITE.SqueezeOptions.endSqueezeOptions(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SplitOptions.startSplitOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numSplits
 */
TFLITE.SplitOptions.addNumSplits = function(builder, numSplits) {
  builder.addFieldInt32(0, numSplits, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SplitOptions.endSplitOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numSplits
 * @returns {flatbuffers.Offset}
 */
TFLITE.SplitOptions.createSplitOptions = function(builder, numSplits) {
  TFLITE.SplitOptions.startSplitOptions(builder);
  TFLITE.SplitOptions.addNumSplits(builder, numSplits);
  return TFLITE.SplitOptions.endSplitOptions(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SplitVOptions.startSplitVOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numSplits
 */
TFLITE.SplitVOptions.addNumSplits = function(builder, numSplits) {
  builder.addFieldInt32(0, numSplits, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SplitVOptions.endSplitVOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numSplits
 * @returns {flatbuffers.Offset}
 */
TFLITE.SplitVOptions.createSplitVOptions = function(builder, numSplits) {
  TFLITE.SplitVOptions.startSplitVOptions(builder);
  TFLITE.SplitVOptions.addNumSplits(builder, numSplits);
  return TFLITE.SplitVOptions.endSplitVOptions(builder);
}

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

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

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

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.StridedSliceOptions.startStridedSliceOptions = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beginMask
 */
TFLITE.StridedSliceOptions.addBeginMask = function(builder, beginMask) {
  builder.addFieldInt32(0, beginMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} endMask
 */
TFLITE.StridedSliceOptions.addEndMask = function(builder, endMask) {
  builder.addFieldInt32(1, endMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} ellipsisMask
 */
TFLITE.StridedSliceOptions.addEllipsisMask = function(builder, ellipsisMask) {
  builder.addFieldInt32(2, ellipsisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} newAxisMask
 */
TFLITE.StridedSliceOptions.addNewAxisMask = function(builder, newAxisMask) {
  builder.addFieldInt32(3, newAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} shrinkAxisMask
 */
TFLITE.StridedSliceOptions.addShrinkAxisMask = function(builder, shrinkAxisMask) {
  builder.addFieldInt32(4, shrinkAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.StridedSliceOptions.endStridedSliceOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beginMask
 * @param {number} endMask
 * @param {number} ellipsisMask
 * @param {number} newAxisMask
 * @param {number} shrinkAxisMask
 * @returns {flatbuffers.Offset}
 */
TFLITE.StridedSliceOptions.createStridedSliceOptions = function(builder, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask) {
  TFLITE.StridedSliceOptions.startStridedSliceOptions(builder);
  TFLITE.StridedSliceOptions.addBeginMask(builder, beginMask);
  TFLITE.StridedSliceOptions.addEndMask(builder, endMask);
  TFLITE.StridedSliceOptions.addEllipsisMask(builder, ellipsisMask);
  TFLITE.StridedSliceOptions.addNewAxisMask(builder, newAxisMask);
  TFLITE.StridedSliceOptions.addShrinkAxisMask(builder, shrinkAxisMask);
  return TFLITE.StridedSliceOptions.endStridedSliceOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LogSoftmaxOptions.startLogSoftmaxOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogSoftmaxOptions.endLogSoftmaxOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogSoftmaxOptions.createLogSoftmaxOptions = function(builder) {
  TFLITE.LogSoftmaxOptions.startLogSoftmaxOptions(builder);
  return TFLITE.LogSoftmaxOptions.endLogSoftmaxOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.CastOptions.prototype.inDataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.CastOptions.prototype.outDataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.CastOptions.startCastOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} inDataType
 */
TFLITE.CastOptions.addInDataType = function(builder, inDataType) {
  builder.addFieldInt8(0, inDataType, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outDataType
 */
TFLITE.CastOptions.addOutDataType = function(builder, outDataType) {
  builder.addFieldInt8(1, outDataType, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.CastOptions.endCastOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} inDataType
 * @param {TFLITE.TensorType} outDataType
 * @returns {flatbuffers.Offset}
 */
TFLITE.CastOptions.createCastOptions = function(builder, inDataType, outDataType) {
  TFLITE.CastOptions.startCastOptions(builder);
  TFLITE.CastOptions.addInDataType(builder, inDataType);
  TFLITE.CastOptions.addOutDataType(builder, outDataType);
  return TFLITE.CastOptions.endCastOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.DequantizeOptions.startDequantizeOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DequantizeOptions.endDequantizeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DequantizeOptions.createDequantizeOptions = function(builder) {
  TFLITE.DequantizeOptions.startDequantizeOptions(builder);
  return TFLITE.DequantizeOptions.endDequantizeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.MaximumMinimumOptions.startMaximumMinimumOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MaximumMinimumOptions.endMaximumMinimumOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MaximumMinimumOptions.createMaximumMinimumOptions = function(builder) {
  TFLITE.MaximumMinimumOptions.startMaximumMinimumOptions(builder);
  return TFLITE.MaximumMinimumOptions.endMaximumMinimumOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.TileOptions.startTileOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TileOptions.endTileOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TileOptions.createTileOptions = function(builder) {
  TFLITE.TileOptions.startTileOptions(builder);
  return TFLITE.TileOptions.endTileOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.ArgMaxOptions.prototype.outputType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ArgMaxOptions.startArgMaxOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outputType
 */
TFLITE.ArgMaxOptions.addOutputType = function(builder, outputType) {
  builder.addFieldInt8(0, outputType, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ArgMaxOptions.endArgMaxOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outputType
 * @returns {flatbuffers.Offset}
 */
TFLITE.ArgMaxOptions.createArgMaxOptions = function(builder, outputType) {
  TFLITE.ArgMaxOptions.startArgMaxOptions(builder);
  TFLITE.ArgMaxOptions.addOutputType(builder, outputType);
  return TFLITE.ArgMaxOptions.endArgMaxOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.ArgMinOptions.prototype.outputType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ArgMinOptions.startArgMinOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outputType
 */
TFLITE.ArgMinOptions.addOutputType = function(builder, outputType) {
  builder.addFieldInt8(0, outputType, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ArgMinOptions.endArgMinOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outputType
 * @returns {flatbuffers.Offset}
 */
TFLITE.ArgMinOptions.createArgMinOptions = function(builder, outputType) {
  TFLITE.ArgMinOptions.startArgMinOptions(builder);
  TFLITE.ArgMinOptions.addOutputType(builder, outputType);
  return TFLITE.ArgMinOptions.endArgMinOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.GreaterOptions.startGreaterOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GreaterOptions.endGreaterOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GreaterOptions.createGreaterOptions = function(builder) {
  TFLITE.GreaterOptions.startGreaterOptions(builder);
  return TFLITE.GreaterOptions.endGreaterOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.GreaterEqualOptions.startGreaterEqualOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GreaterEqualOptions.endGreaterEqualOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GreaterEqualOptions.createGreaterEqualOptions = function(builder) {
  TFLITE.GreaterEqualOptions.startGreaterEqualOptions(builder);
  return TFLITE.GreaterEqualOptions.endGreaterEqualOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LessOptions.startLessOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LessOptions.endLessOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LessOptions.createLessOptions = function(builder) {
  TFLITE.LessOptions.startLessOptions(builder);
  return TFLITE.LessOptions.endLessOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LessEqualOptions.startLessEqualOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LessEqualOptions.endLessEqualOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LessEqualOptions.createLessEqualOptions = function(builder) {
  TFLITE.LessEqualOptions.startLessEqualOptions(builder);
  return TFLITE.LessEqualOptions.endLessEqualOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.NegOptions.startNegOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NegOptions.endNegOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NegOptions.createNegOptions = function(builder) {
  TFLITE.NegOptions.startNegOptions(builder);
  return TFLITE.NegOptions.endNegOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SelectOptions.startSelectOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SelectOptions.endSelectOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SelectOptions.createSelectOptions = function(builder) {
  TFLITE.SelectOptions.startSelectOptions(builder);
  return TFLITE.SelectOptions.endSelectOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SliceOptions.startSliceOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SliceOptions.endSliceOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SliceOptions.createSliceOptions = function(builder) {
  TFLITE.SliceOptions.startSliceOptions(builder);
  return TFLITE.SliceOptions.endSliceOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.Padding}
 */
TFLITE.TransposeConvOptions.prototype.padding = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.Padding} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.Padding.SAME;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.TransposeConvOptions.startTransposeConvOptions = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 */
TFLITE.TransposeConvOptions.addPadding = function(builder, padding) {
  builder.addFieldInt8(0, padding, TFLITE.Padding.SAME);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideW
 */
TFLITE.TransposeConvOptions.addStrideW = function(builder, strideW) {
  builder.addFieldInt32(1, strideW, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideH
 */
TFLITE.TransposeConvOptions.addStrideH = function(builder, strideH) {
  builder.addFieldInt32(2, strideH, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.TransposeConvOptions.endTransposeConvOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.Padding} padding
 * @param {number} strideW
 * @param {number} strideH
 * @returns {flatbuffers.Offset}
 */
TFLITE.TransposeConvOptions.createTransposeConvOptions = function(builder, padding, strideW, strideH) {
  TFLITE.TransposeConvOptions.startTransposeConvOptions(builder);
  TFLITE.TransposeConvOptions.addPadding(builder, padding);
  TFLITE.TransposeConvOptions.addStrideW(builder, strideW);
  TFLITE.TransposeConvOptions.addStrideH(builder, strideH);
  return TFLITE.TransposeConvOptions.endTransposeConvOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ExpandDimsOptions.startExpandDimsOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ExpandDimsOptions.endExpandDimsOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ExpandDimsOptions.createExpandDimsOptions = function(builder) {
  TFLITE.ExpandDimsOptions.startExpandDimsOptions(builder);
  return TFLITE.ExpandDimsOptions.endExpandDimsOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.SparseToDenseOptions.prototype.validateIndices = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SparseToDenseOptions.startSparseToDenseOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} validateIndices
 */
TFLITE.SparseToDenseOptions.addValidateIndices = function(builder, validateIndices) {
  builder.addFieldInt8(0, +validateIndices, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparseToDenseOptions.endSparseToDenseOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} validateIndices
 * @returns {flatbuffers.Offset}
 */
TFLITE.SparseToDenseOptions.createSparseToDenseOptions = function(builder, validateIndices) {
  TFLITE.SparseToDenseOptions.startSparseToDenseOptions(builder);
  TFLITE.SparseToDenseOptions.addValidateIndices(builder, validateIndices);
  return TFLITE.SparseToDenseOptions.endSparseToDenseOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.EqualOptions.startEqualOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.EqualOptions.endEqualOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.EqualOptions.createEqualOptions = function(builder) {
  TFLITE.EqualOptions.startEqualOptions(builder);
  return TFLITE.EqualOptions.endEqualOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.NotEqualOptions.startNotEqualOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NotEqualOptions.endNotEqualOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NotEqualOptions.createNotEqualOptions = function(builder) {
  TFLITE.NotEqualOptions.startNotEqualOptions(builder);
  return TFLITE.NotEqualOptions.endNotEqualOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.ShapeOptions.prototype.outType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.FLOAT32;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ShapeOptions.startShapeOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outType
 */
TFLITE.ShapeOptions.addOutType = function(builder, outType) {
  builder.addFieldInt8(0, outType, TFLITE.TensorType.FLOAT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ShapeOptions.endShapeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} outType
 * @returns {flatbuffers.Offset}
 */
TFLITE.ShapeOptions.createShapeOptions = function(builder, outType) {
  TFLITE.ShapeOptions.startShapeOptions(builder);
  TFLITE.ShapeOptions.addOutType(builder, outType);
  return TFLITE.ShapeOptions.endShapeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.RankOptions.startRankOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.RankOptions.endRankOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.RankOptions.createRankOptions = function(builder) {
  TFLITE.RankOptions.startRankOptions(builder);
  return TFLITE.RankOptions.endRankOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.PowOptions.startPowOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PowOptions.endPowOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PowOptions.createPowOptions = function(builder) {
  TFLITE.PowOptions.startPowOptions(builder);
  return TFLITE.PowOptions.endPowOptions(builder);
}

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

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

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.FakeQuantOptions.startFakeQuantOptions = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} min
 */
TFLITE.FakeQuantOptions.addMin = function(builder, min) {
  builder.addFieldFloat32(0, min, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} max
 */
TFLITE.FakeQuantOptions.addMax = function(builder, max) {
  builder.addFieldFloat32(1, max, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numBits
 */
TFLITE.FakeQuantOptions.addNumBits = function(builder, numBits) {
  builder.addFieldInt32(2, numBits, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} narrowRange
 */
TFLITE.FakeQuantOptions.addNarrowRange = function(builder, narrowRange) {
  builder.addFieldInt8(3, +narrowRange, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FakeQuantOptions.endFakeQuantOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} min
 * @param {number} max
 * @param {number} numBits
 * @param {boolean} narrowRange
 * @returns {flatbuffers.Offset}
 */
TFLITE.FakeQuantOptions.createFakeQuantOptions = function(builder, min, max, numBits, narrowRange) {
  TFLITE.FakeQuantOptions.startFakeQuantOptions(builder);
  TFLITE.FakeQuantOptions.addMin(builder, min);
  TFLITE.FakeQuantOptions.addMax(builder, max);
  TFLITE.FakeQuantOptions.addNumBits(builder, numBits);
  TFLITE.FakeQuantOptions.addNarrowRange(builder, narrowRange);
  return TFLITE.FakeQuantOptions.endFakeQuantOptions(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.PackOptions.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
 */
TFLITE.PackOptions.startPackOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} valuesCount
 */
TFLITE.PackOptions.addValuesCount = function(builder, valuesCount) {
  builder.addFieldInt32(0, valuesCount, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.PackOptions.endPackOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} valuesCount
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
TFLITE.PackOptions.createPackOptions = function(builder, valuesCount, axis) {
  TFLITE.PackOptions.startPackOptions(builder);
  TFLITE.PackOptions.addValuesCount(builder, valuesCount);
  TFLITE.PackOptions.addAxis(builder, axis);
  return TFLITE.PackOptions.endPackOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LogicalOrOptions.startLogicalOrOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalOrOptions.endLogicalOrOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalOrOptions.createLogicalOrOptions = function(builder) {
  TFLITE.LogicalOrOptions.startLogicalOrOptions(builder);
  return TFLITE.LogicalOrOptions.endLogicalOrOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.OneHotOptions.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
 */
TFLITE.OneHotOptions.startOneHotOptions = function(builder) {
  builder.startObject(1);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.OneHotOptions.endOneHotOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
TFLITE.OneHotOptions.createOneHotOptions = function(builder, axis) {
  TFLITE.OneHotOptions.startOneHotOptions(builder);
  TFLITE.OneHotOptions.addAxis(builder, axis);
  return TFLITE.OneHotOptions.endOneHotOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.AbsOptions.startAbsOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.AbsOptions.endAbsOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.AbsOptions.createAbsOptions = function(builder) {
  TFLITE.AbsOptions.startAbsOptions(builder);
  return TFLITE.AbsOptions.endAbsOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.HardSwishOptions.startHardSwishOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.HardSwishOptions.endHardSwishOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.HardSwishOptions.createHardSwishOptions = function(builder) {
  TFLITE.HardSwishOptions.startHardSwishOptions(builder);
  return TFLITE.HardSwishOptions.endHardSwishOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LogicalAndOptions.startLogicalAndOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalAndOptions.endLogicalAndOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalAndOptions.createLogicalAndOptions = function(builder) {
  TFLITE.LogicalAndOptions.startLogicalAndOptions(builder);
  return TFLITE.LogicalAndOptions.endLogicalAndOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.LogicalNotOptions.startLogicalNotOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalNotOptions.endLogicalNotOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LogicalNotOptions.createLogicalNotOptions = function(builder) {
  TFLITE.LogicalNotOptions.startLogicalNotOptions(builder);
  return TFLITE.LogicalNotOptions.endLogicalNotOptions(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.UnpackOptions.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
 */
TFLITE.UnpackOptions.startUnpackOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} num
 */
TFLITE.UnpackOptions.addNum = function(builder, num) {
  builder.addFieldInt32(0, num, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.UnpackOptions.endUnpackOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} num
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
TFLITE.UnpackOptions.createUnpackOptions = function(builder, num, axis) {
  TFLITE.UnpackOptions.startUnpackOptions(builder);
  TFLITE.UnpackOptions.addNum(builder, num);
  TFLITE.UnpackOptions.addAxis(builder, axis);
  return TFLITE.UnpackOptions.endUnpackOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.FloorDivOptions.startFloorDivOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FloorDivOptions.endFloorDivOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FloorDivOptions.createFloorDivOptions = function(builder) {
  TFLITE.FloorDivOptions.startFloorDivOptions(builder);
  return TFLITE.FloorDivOptions.endFloorDivOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SquareOptions.startSquareOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SquareOptions.endSquareOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SquareOptions.createSquareOptions = function(builder) {
  TFLITE.SquareOptions.startSquareOptions(builder);
  return TFLITE.SquareOptions.endSquareOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ZerosLikeOptions.startZerosLikeOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ZerosLikeOptions.endZerosLikeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ZerosLikeOptions.createZerosLikeOptions = function(builder) {
  TFLITE.ZerosLikeOptions.startZerosLikeOptions(builder);
  return TFLITE.ZerosLikeOptions.endZerosLikeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.FillOptions.startFillOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FillOptions.endFillOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FillOptions.createFillOptions = function(builder) {
  TFLITE.FillOptions.startFillOptions(builder);
  return TFLITE.FillOptions.endFillOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.FloorModOptions.startFloorModOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FloorModOptions.endFloorModOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.FloorModOptions.createFloorModOptions = function(builder) {
  TFLITE.FloorModOptions.startFloorModOptions(builder);
  return TFLITE.FloorModOptions.endFloorModOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.RangeOptions.startRangeOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.RangeOptions.endRangeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.RangeOptions.createRangeOptions = function(builder) {
  TFLITE.RangeOptions.startRangeOptions(builder);
  return TFLITE.RangeOptions.endRangeOptions(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.LeakyReluOptions.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
 */
TFLITE.LeakyReluOptions.startLeakyReluOptions = function(builder) {
  builder.startObject(1);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.LeakyReluOptions.endLeakyReluOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 * @returns {flatbuffers.Offset}
 */
TFLITE.LeakyReluOptions.createLeakyReluOptions = function(builder, alpha) {
  TFLITE.LeakyReluOptions.startLeakyReluOptions(builder);
  TFLITE.LeakyReluOptions.addAlpha(builder, alpha);
  return TFLITE.LeakyReluOptions.endLeakyReluOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SquaredDifferenceOptions.startSquaredDifferenceOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SquaredDifferenceOptions.endSquaredDifferenceOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SquaredDifferenceOptions.createSquaredDifferenceOptions = function(builder) {
  TFLITE.SquaredDifferenceOptions.startSquaredDifferenceOptions(builder);
  return TFLITE.SquaredDifferenceOptions.endSquaredDifferenceOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.MirrorPadMode}
 */
TFLITE.MirrorPadOptions.prototype.mode = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.MirrorPadMode} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.MirrorPadMode.REFLECT;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.MirrorPadOptions.startMirrorPadOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.MirrorPadMode} mode
 */
TFLITE.MirrorPadOptions.addMode = function(builder, mode) {
  builder.addFieldInt8(0, mode, TFLITE.MirrorPadMode.REFLECT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MirrorPadOptions.endMirrorPadOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.MirrorPadMode} mode
 * @returns {flatbuffers.Offset}
 */
TFLITE.MirrorPadOptions.createMirrorPadOptions = function(builder, mode) {
  TFLITE.MirrorPadOptions.startMirrorPadOptions(builder);
  TFLITE.MirrorPadOptions.addMode(builder, mode);
  return TFLITE.MirrorPadOptions.endMirrorPadOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.TensorType}
 */
TFLITE.UniqueOptions.prototype.idxOutType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.TensorType} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.TensorType.INT32;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.UniqueOptions.startUniqueOptions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} idxOutType
 */
TFLITE.UniqueOptions.addIdxOutType = function(builder, idxOutType) {
  builder.addFieldInt8(0, idxOutType, TFLITE.TensorType.INT32);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.UniqueOptions.endUniqueOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.TensorType} idxOutType
 * @returns {flatbuffers.Offset}
 */
TFLITE.UniqueOptions.createUniqueOptions = function(builder, idxOutType) {
  TFLITE.UniqueOptions.startUniqueOptions(builder);
  TFLITE.UniqueOptions.addIdxOutType(builder, idxOutType);
  return TFLITE.UniqueOptions.endUniqueOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ReverseV2Options.startReverseV2Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReverseV2Options.endReverseV2Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReverseV2Options.createReverseV2Options = function(builder) {
  TFLITE.ReverseV2Options.startReverseV2Options(builder);
  return TFLITE.ReverseV2Options.endReverseV2Options(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.AddNOptions.startAddNOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.AddNOptions.endAddNOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.AddNOptions.createAddNOptions = function(builder) {
  TFLITE.AddNOptions.startAddNOptions(builder);
  return TFLITE.AddNOptions.endAddNOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.GatherNdOptions.startGatherNdOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GatherNdOptions.endGatherNdOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.GatherNdOptions.createGatherNdOptions = function(builder) {
  TFLITE.GatherNdOptions.startGatherNdOptions(builder);
  return TFLITE.GatherNdOptions.endGatherNdOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.WhereOptions.startWhereOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.WhereOptions.endWhereOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.WhereOptions.createWhereOptions = function(builder) {
  TFLITE.WhereOptions.startWhereOptions(builder);
  return TFLITE.WhereOptions.endWhereOptions(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ReverseSequenceOptions.startReverseSequenceOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} seqDim
 */
TFLITE.ReverseSequenceOptions.addSeqDim = function(builder, seqDim) {
  builder.addFieldInt32(0, seqDim, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} batchDim
 */
TFLITE.ReverseSequenceOptions.addBatchDim = function(builder, batchDim) {
  builder.addFieldInt32(1, batchDim, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReverseSequenceOptions.endReverseSequenceOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} seqDim
 * @param {number} batchDim
 * @returns {flatbuffers.Offset}
 */
TFLITE.ReverseSequenceOptions.createReverseSequenceOptions = function(builder, seqDim, batchDim) {
  TFLITE.ReverseSequenceOptions.startReverseSequenceOptions(builder);
  TFLITE.ReverseSequenceOptions.addSeqDim(builder, seqDim);
  TFLITE.ReverseSequenceOptions.addBatchDim(builder, batchDim);
  return TFLITE.ReverseSequenceOptions.endReverseSequenceOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.MatrixDiagOptions.startMatrixDiagOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MatrixDiagOptions.endMatrixDiagOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MatrixDiagOptions.createMatrixDiagOptions = function(builder) {
  TFLITE.MatrixDiagOptions.startMatrixDiagOptions(builder);
  return TFLITE.MatrixDiagOptions.endMatrixDiagOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.QuantizeOptions.startQuantizeOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizeOptions.endQuantizeOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.QuantizeOptions.createQuantizeOptions = function(builder) {
  TFLITE.QuantizeOptions.startQuantizeOptions(builder);
  return TFLITE.QuantizeOptions.endQuantizeOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.MatrixSetDiagOptions.startMatrixSetDiagOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MatrixSetDiagOptions.endMatrixSetDiagOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.MatrixSetDiagOptions.createMatrixSetDiagOptions = function(builder) {
  TFLITE.MatrixSetDiagOptions.startMatrixSetDiagOptions(builder);
  return TFLITE.MatrixSetDiagOptions.endMatrixSetDiagOptions(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.IfOptions.startIfOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} thenSubgraphIndex
 */
TFLITE.IfOptions.addThenSubgraphIndex = function(builder, thenSubgraphIndex) {
  builder.addFieldInt32(0, thenSubgraphIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} elseSubgraphIndex
 */
TFLITE.IfOptions.addElseSubgraphIndex = function(builder, elseSubgraphIndex) {
  builder.addFieldInt32(1, elseSubgraphIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.IfOptions.endIfOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} thenSubgraphIndex
 * @param {number} elseSubgraphIndex
 * @returns {flatbuffers.Offset}
 */
TFLITE.IfOptions.createIfOptions = function(builder, thenSubgraphIndex, elseSubgraphIndex) {
  TFLITE.IfOptions.startIfOptions(builder);
  TFLITE.IfOptions.addThenSubgraphIndex(builder, thenSubgraphIndex);
  TFLITE.IfOptions.addElseSubgraphIndex(builder, elseSubgraphIndex);
  return TFLITE.IfOptions.endIfOptions(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.WhileOptions.startWhileOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} condSubgraphIndex
 */
TFLITE.WhileOptions.addCondSubgraphIndex = function(builder, condSubgraphIndex) {
  builder.addFieldInt32(0, condSubgraphIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} bodySubgraphIndex
 */
TFLITE.WhileOptions.addBodySubgraphIndex = function(builder, bodySubgraphIndex) {
  builder.addFieldInt32(1, bodySubgraphIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.WhileOptions.endWhileOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} condSubgraphIndex
 * @param {number} bodySubgraphIndex
 * @returns {flatbuffers.Offset}
 */
TFLITE.WhileOptions.createWhileOptions = function(builder, condSubgraphIndex, bodySubgraphIndex) {
  TFLITE.WhileOptions.startWhileOptions(builder);
  TFLITE.WhileOptions.addCondSubgraphIndex(builder, condSubgraphIndex);
  TFLITE.WhileOptions.addBodySubgraphIndex(builder, bodySubgraphIndex);
  return TFLITE.WhileOptions.endWhileOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.NonMaxSuppressionV4Options.startNonMaxSuppressionV4Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NonMaxSuppressionV4Options.endNonMaxSuppressionV4Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NonMaxSuppressionV4Options.createNonMaxSuppressionV4Options = function(builder) {
  TFLITE.NonMaxSuppressionV4Options.startNonMaxSuppressionV4Options(builder);
  return TFLITE.NonMaxSuppressionV4Options.endNonMaxSuppressionV4Options(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.NonMaxSuppressionV5Options.startNonMaxSuppressionV5Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NonMaxSuppressionV5Options.endNonMaxSuppressionV5Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.NonMaxSuppressionV5Options.createNonMaxSuppressionV5Options = function(builder) {
  TFLITE.NonMaxSuppressionV5Options.startNonMaxSuppressionV5Options(builder);
  return TFLITE.NonMaxSuppressionV5Options.endNonMaxSuppressionV5Options(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.ScatterNdOptions.startScatterNdOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ScatterNdOptions.endScatterNdOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.ScatterNdOptions.createScatterNdOptions = function(builder) {
  TFLITE.ScatterNdOptions.startScatterNdOptions(builder);
  return TFLITE.ScatterNdOptions.endScatterNdOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SelectV2Options.startSelectV2Options = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SelectV2Options.endSelectV2Options = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SelectV2Options.createSelectV2Options = function(builder) {
  TFLITE.SelectV2Options.startSelectV2Options(builder);
  return TFLITE.SelectV2Options.endSelectV2Options(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.DensifyOptions.startDensifyOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DensifyOptions.endDensifyOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.DensifyOptions.createDensifyOptions = function(builder) {
  TFLITE.DensifyOptions.startDensifyOptions(builder);
  return TFLITE.DensifyOptions.endDensifyOptions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SegmentSumOptions.startSegmentSumOptions = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SegmentSumOptions.endSegmentSumOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SegmentSumOptions.createSegmentSumOptions = function(builder) {
  TFLITE.SegmentSumOptions.startSegmentSumOptions(builder);
  return TFLITE.SegmentSumOptions.endSegmentSumOptions(builder);
}

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

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

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

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

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

/**
 * @returns {boolean}
 */
TFLITE.BatchMatMulOptions.prototype.adjointLhs = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
TFLITE.BatchMatMulOptions.prototype.adjointRhs = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.BatchMatMulOptions.startBatchMatMulOptions = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjointLhs
 */
TFLITE.BatchMatMulOptions.addAdjointLhs = function(builder, adjointLhs) {
  builder.addFieldInt8(0, +adjointLhs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjointRhs
 */
TFLITE.BatchMatMulOptions.addAdjointRhs = function(builder, adjointRhs) {
  builder.addFieldInt8(1, +adjointRhs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.BatchMatMulOptions.endBatchMatMulOptions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjointLhs
 * @param {boolean} adjointRhs
 * @returns {flatbuffers.Offset}
 */
TFLITE.BatchMatMulOptions.createBatchMatMulOptions = function(builder, adjointLhs, adjointRhs) {
  TFLITE.BatchMatMulOptions.startBatchMatMulOptions(builder);
  TFLITE.BatchMatMulOptions.addAdjointLhs(builder, adjointLhs);
  TFLITE.BatchMatMulOptions.addAdjointRhs(builder, adjointRhs);
  return TFLITE.BatchMatMulOptions.endBatchMatMulOptions(builder);
}

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

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

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

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

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

/**
 * @returns {TFLITE.BuiltinOperator}
 */
TFLITE.OperatorCode.prototype.builtinCode = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {TFLITE.BuiltinOperator} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.BuiltinOperator.ADD;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.OperatorCode.startOperatorCode = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.BuiltinOperator} builtinCode
 */
TFLITE.OperatorCode.addBuiltinCode = function(builder, builtinCode) {
  builder.addFieldInt8(0, builtinCode, TFLITE.BuiltinOperator.ADD);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} customCodeOffset
 */
TFLITE.OperatorCode.addCustomCode = function(builder, customCodeOffset) {
  builder.addFieldOffset(1, customCodeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} version
 */
TFLITE.OperatorCode.addVersion = function(builder, version) {
  builder.addFieldInt32(2, version, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.OperatorCode.endOperatorCode = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.BuiltinOperator} builtinCode
 * @param {flatbuffers.Offset} customCodeOffset
 * @param {number} version
 * @returns {flatbuffers.Offset}
 */
TFLITE.OperatorCode.createOperatorCode = function(builder, builtinCode, customCodeOffset, version) {
  TFLITE.OperatorCode.startOperatorCode(builder);
  TFLITE.OperatorCode.addBuiltinCode(builder, builtinCode);
  TFLITE.OperatorCode.addCustomCode(builder, customCodeOffset);
  TFLITE.OperatorCode.addVersion(builder, version);
  return TFLITE.OperatorCode.endOperatorCode(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.Operator.prototype.opcodeIndex = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Operator.prototype.inputs = 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}
 */
TFLITE.Operator.prototype.inputsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Operator.prototype.inputsArray = 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}
 */
TFLITE.Operator.prototype.outputs = 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}
 */
TFLITE.Operator.prototype.outputsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Operator.prototype.outputsArray = 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 {TFLITE.BuiltinOptions}
 */
TFLITE.Operator.prototype.builtinOptionsType = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {TFLITE.BuiltinOptions} */ (this.bb.readUint8(this.bb_pos + offset)) : TFLITE.BuiltinOptions.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
TFLITE.Operator.prototype.builtinOptions = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Operator.prototype.customOptions = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

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

/**
 * @returns {Uint8Array}
 */
TFLITE.Operator.prototype.customOptionsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  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 {TFLITE.CustomOptionsFormat}
 */
TFLITE.Operator.prototype.customOptionsFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? /** @type {TFLITE.CustomOptionsFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : TFLITE.CustomOptionsFormat.FLEXBUFFERS;
};

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

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

/**
 * @returns {Int8Array}
 */
TFLITE.Operator.prototype.mutatingVariableInputsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  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}
 */
TFLITE.Operator.prototype.intermediates = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

/**
 * @returns {Int32Array}
 */
TFLITE.Operator.prototype.intermediatesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  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
 */
TFLITE.Operator.startOperator = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} opcodeIndex
 */
TFLITE.Operator.addOpcodeIndex = function(builder, opcodeIndex) {
  builder.addFieldInt32(0, opcodeIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputsOffset
 */
TFLITE.Operator.addInputs = function(builder, inputsOffset) {
  builder.addFieldOffset(1, inputsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createInputsVector = 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
 */
TFLITE.Operator.startInputsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputsOffset
 */
TFLITE.Operator.addOutputs = function(builder, outputsOffset) {
  builder.addFieldOffset(2, outputsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createOutputsVector = 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
 */
TFLITE.Operator.startOutputsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.BuiltinOptions} builtinOptionsType
 */
TFLITE.Operator.addBuiltinOptionsType = function(builder, builtinOptionsType) {
  builder.addFieldInt8(3, builtinOptionsType, TFLITE.BuiltinOptions.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} builtinOptionsOffset
 */
TFLITE.Operator.addBuiltinOptions = function(builder, builtinOptionsOffset) {
  builder.addFieldOffset(4, builtinOptionsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} customOptionsOffset
 */
TFLITE.Operator.addCustomOptions = function(builder, customOptionsOffset) {
  builder.addFieldOffset(5, customOptionsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createCustomOptionsVector = 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
 */
TFLITE.Operator.startCustomOptionsVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {TFLITE.CustomOptionsFormat} customOptionsFormat
 */
TFLITE.Operator.addCustomOptionsFormat = function(builder, customOptionsFormat) {
  builder.addFieldInt8(6, customOptionsFormat, TFLITE.CustomOptionsFormat.FLEXBUFFERS);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} mutatingVariableInputsOffset
 */
TFLITE.Operator.addMutatingVariableInputs = function(builder, mutatingVariableInputsOffset) {
  builder.addFieldOffset(7, mutatingVariableInputsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<boolean>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createMutatingVariableInputsVector = 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
 */
TFLITE.Operator.startMutatingVariableInputsVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} intermediatesOffset
 */
TFLITE.Operator.addIntermediates = function(builder, intermediatesOffset) {
  builder.addFieldOffset(8, intermediatesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createIntermediatesVector = 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
 */
TFLITE.Operator.startIntermediatesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.endOperator = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} opcodeIndex
 * @param {flatbuffers.Offset} inputsOffset
 * @param {flatbuffers.Offset} outputsOffset
 * @param {TFLITE.BuiltinOptions} builtinOptionsType
 * @param {flatbuffers.Offset} builtinOptionsOffset
 * @param {flatbuffers.Offset} customOptionsOffset
 * @param {TFLITE.CustomOptionsFormat} customOptionsFormat
 * @param {flatbuffers.Offset} mutatingVariableInputsOffset
 * @param {flatbuffers.Offset} intermediatesOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Operator.createOperator = function(builder, opcodeIndex, inputsOffset, outputsOffset, builtinOptionsType, builtinOptionsOffset, customOptionsOffset, customOptionsFormat, mutatingVariableInputsOffset, intermediatesOffset) {
  TFLITE.Operator.startOperator(builder);
  TFLITE.Operator.addOpcodeIndex(builder, opcodeIndex);
  TFLITE.Operator.addInputs(builder, inputsOffset);
  TFLITE.Operator.addOutputs(builder, outputsOffset);
  TFLITE.Operator.addBuiltinOptionsType(builder, builtinOptionsType);
  TFLITE.Operator.addBuiltinOptions(builder, builtinOptionsOffset);
  TFLITE.Operator.addCustomOptions(builder, customOptionsOffset);
  TFLITE.Operator.addCustomOptionsFormat(builder, customOptionsFormat);
  TFLITE.Operator.addMutatingVariableInputs(builder, mutatingVariableInputsOffset);
  TFLITE.Operator.addIntermediates(builder, intermediatesOffset);
  return TFLITE.Operator.endOperator(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @param {TFLITE.Tensor=} obj
 * @returns {TFLITE.Tensor}
 */
TFLITE.SubGraph.prototype.tensors = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new TFLITE.Tensor).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
TFLITE.SubGraph.prototype.tensorsLength = 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}
 */
TFLITE.SubGraph.prototype.inputs = 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}
 */
TFLITE.SubGraph.prototype.inputsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.SubGraph.prototype.inputsArray = 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}
 */
TFLITE.SubGraph.prototype.outputs = 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}
 */
TFLITE.SubGraph.prototype.outputsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.SubGraph.prototype.outputsArray = 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
 * @param {TFLITE.Operator=} obj
 * @returns {TFLITE.Operator}
 */
TFLITE.SubGraph.prototype.operators = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new TFLITE.Operator).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.SubGraph.startSubGraph = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorsOffset
 */
TFLITE.SubGraph.addTensors = function(builder, tensorsOffset) {
  builder.addFieldOffset(0, tensorsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.createTensorsVector = 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
 */
TFLITE.SubGraph.startTensorsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputsOffset
 */
TFLITE.SubGraph.addInputs = function(builder, inputsOffset) {
  builder.addFieldOffset(1, inputsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.createInputsVector = 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
 */
TFLITE.SubGraph.startInputsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputsOffset
 */
TFLITE.SubGraph.addOutputs = function(builder, outputsOffset) {
  builder.addFieldOffset(2, outputsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.createOutputsVector = 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
 */
TFLITE.SubGraph.startOutputsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} operatorsOffset
 */
TFLITE.SubGraph.addOperators = function(builder, operatorsOffset) {
  builder.addFieldOffset(3, operatorsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.createOperatorsVector = 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
 */
TFLITE.SubGraph.startOperatorsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
TFLITE.SubGraph.addName = function(builder, nameOffset) {
  builder.addFieldOffset(4, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.endSubGraph = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorsOffset
 * @param {flatbuffers.Offset} inputsOffset
 * @param {flatbuffers.Offset} outputsOffset
 * @param {flatbuffers.Offset} operatorsOffset
 * @param {flatbuffers.Offset} nameOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.SubGraph.createSubGraph = function(builder, tensorsOffset, inputsOffset, outputsOffset, operatorsOffset, nameOffset) {
  TFLITE.SubGraph.startSubGraph(builder);
  TFLITE.SubGraph.addTensors(builder, tensorsOffset);
  TFLITE.SubGraph.addInputs(builder, inputsOffset);
  TFLITE.SubGraph.addOutputs(builder, outputsOffset);
  TFLITE.SubGraph.addOperators(builder, operatorsOffset);
  TFLITE.SubGraph.addName(builder, nameOffset);
  return TFLITE.SubGraph.endSubGraph(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Buffer.prototype.data = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

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

/**
 * @returns {Uint8Array}
 */
TFLITE.Buffer.prototype.dataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  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 {flatbuffers.Builder} builder
 */
TFLITE.Buffer.startBuffer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
TFLITE.Buffer.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Buffer.createDataVector = 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
 */
TFLITE.Buffer.startDataVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Buffer.endBuffer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Buffer.createBuffer = function(builder, dataOffset) {
  TFLITE.Buffer.startBuffer(builder);
  TFLITE.Buffer.addData(builder, dataOffset);
  return TFLITE.Buffer.endBuffer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
TFLITE.Metadata.prototype.buffer = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.Metadata.startMetadata = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
TFLITE.Metadata.addName = function(builder, nameOffset) {
  builder.addFieldOffset(0, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} buffer
 */
TFLITE.Metadata.addBuffer = function(builder, buffer) {
  builder.addFieldInt32(1, buffer, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Metadata.endMetadata = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 * @param {number} buffer
 * @returns {flatbuffers.Offset}
 */
TFLITE.Metadata.createMetadata = function(builder, nameOffset, buffer) {
  TFLITE.Metadata.startMetadata(builder);
  TFLITE.Metadata.addName(builder, nameOffset);
  TFLITE.Metadata.addBuffer(builder, buffer);
  return TFLITE.Metadata.endMetadata(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {boolean}
 */
TFLITE.Model.bufferHasIdentifier = function(bb) {
  return bb.__has_identifier('TFL3');
};

/**
 * @returns {number}
 */
TFLITE.Model.prototype.version = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @param {TFLITE.OperatorCode=} obj
 * @returns {TFLITE.OperatorCode}
 */
TFLITE.Model.prototype.operatorCodes = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new TFLITE.OperatorCode).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {number} index
 * @param {TFLITE.SubGraph=} obj
 * @returns {TFLITE.SubGraph}
 */
TFLITE.Model.prototype.subgraphs = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new TFLITE.SubGraph).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
TFLITE.Model.prototype.description = 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
 * @param {TFLITE.Buffer=} obj
 * @returns {TFLITE.Buffer}
 */
TFLITE.Model.prototype.buffers = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new TFLITE.Buffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {number} index
 * @returns {number}
 */
TFLITE.Model.prototype.metadataBuffer = 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}
 */
TFLITE.Model.prototype.metadataBufferLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
TFLITE.Model.prototype.metadataBufferArray = 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
 * @param {TFLITE.Metadata=} obj
 * @returns {TFLITE.Metadata}
 */
TFLITE.Model.prototype.metadata = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? (obj || new TFLITE.Metadata).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
TFLITE.Model.startModel = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} version
 */
TFLITE.Model.addVersion = function(builder, version) {
  builder.addFieldInt32(0, version, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} operatorCodesOffset
 */
TFLITE.Model.addOperatorCodes = function(builder, operatorCodesOffset) {
  builder.addFieldOffset(1, operatorCodesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createOperatorCodesVector = 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
 */
TFLITE.Model.startOperatorCodesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} subgraphsOffset
 */
TFLITE.Model.addSubgraphs = function(builder, subgraphsOffset) {
  builder.addFieldOffset(2, subgraphsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createSubgraphsVector = 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
 */
TFLITE.Model.startSubgraphsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptionOffset
 */
TFLITE.Model.addDescription = function(builder, descriptionOffset) {
  builder.addFieldOffset(3, descriptionOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} buffersOffset
 */
TFLITE.Model.addBuffers = function(builder, buffersOffset) {
  builder.addFieldOffset(4, buffersOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createBuffersVector = 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
 */
TFLITE.Model.startBuffersVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} metadataBufferOffset
 */
TFLITE.Model.addMetadataBuffer = function(builder, metadataBufferOffset) {
  builder.addFieldOffset(5, metadataBufferOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createMetadataBufferVector = 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
 */
TFLITE.Model.startMetadataBufferVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} metadataOffset
 */
TFLITE.Model.addMetadata = function(builder, metadataOffset) {
  builder.addFieldOffset(6, metadataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createMetadataVector = 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
 */
TFLITE.Model.startMetadataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.endModel = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
TFLITE.Model.finishModelBuffer = function(builder, offset) {
  builder.finish(offset, 'TFL3');
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
TFLITE.Model.finishSizePrefixedModelBuffer = function(builder, offset) {
  builder.finish(offset, 'TFL3', true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} version
 * @param {flatbuffers.Offset} operatorCodesOffset
 * @param {flatbuffers.Offset} subgraphsOffset
 * @param {flatbuffers.Offset} descriptionOffset
 * @param {flatbuffers.Offset} buffersOffset
 * @param {flatbuffers.Offset} metadataBufferOffset
 * @param {flatbuffers.Offset} metadataOffset
 * @returns {flatbuffers.Offset}
 */
TFLITE.Model.createModel = function(builder, version, operatorCodesOffset, subgraphsOffset, descriptionOffset, buffersOffset, metadataBufferOffset, metadataOffset) {
  TFLITE.Model.startModel(builder);
  TFLITE.Model.addVersion(builder, version);
  TFLITE.Model.addOperatorCodes(builder, operatorCodesOffset);
  TFLITE.Model.addSubgraphs(builder, subgraphsOffset);
  TFLITE.Model.addDescription(builder, descriptionOffset);
  TFLITE.Model.addBuffers(builder, buffersOffset);
  TFLITE.Model.addMetadataBuffer(builder, metadataBufferOffset);
  TFLITE.Model.addMetadata(builder, metadataOffset);
  return TFLITE.Model.endModel(builder);
}

if (typeof module !== 'undefined' && typeof module.exports === 'object') {
  module.exports = TFLITE;
}
