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

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

/**
 * @enum {number}
 */
armnnSerializer.ActivationFunction = {
  Sigmoid: 0,
  TanH: 1,
  Linear: 2,
  ReLu: 3,
  BoundedReLu: 4,
  SoftReLu: 5,
  LeakyReLu: 6,
  Abs: 7,
  Sqrt: 8,
  Square: 9,
  Elu: 10,
  HardSwish: 11
};

/**
 * @enum {string}
 */
armnnSerializer.ActivationFunctionName = {
  '0': 'Sigmoid',
  '1': 'TanH',
  '2': 'Linear',
  '3': 'ReLu',
  '4': 'BoundedReLu',
  '5': 'SoftReLu',
  '6': 'LeakyReLu',
  '7': 'Abs',
  '8': 'Sqrt',
  '9': 'Square',
  '10': 'Elu',
  '11': 'HardSwish'
};

/**
 * @enum {number}
 */
armnnSerializer.ArgMinMaxFunction = {
  Min: 0,
  Max: 1
};

/**
 * @enum {string}
 */
armnnSerializer.ArgMinMaxFunctionName = {
  '0': 'Min',
  '1': 'Max'
};

/**
 * @enum {number}
 */
armnnSerializer.DataType = {
  Float16: 0,
  Float32: 1,
  QuantisedAsymm8: 2,
  Signed32: 3,
  Boolean: 4,
  QuantisedSymm16: 5,
  QAsymmU8: 6,
  QSymmS16: 7,
  QAsymmS8: 8,
  QSymmS8: 9
};

/**
 * @enum {string}
 */
armnnSerializer.DataTypeName = {
  '0': 'Float16',
  '1': 'Float32',
  '2': 'QuantisedAsymm8',
  '3': 'Signed32',
  '4': 'Boolean',
  '5': 'QuantisedSymm16',
  '6': 'QAsymmU8',
  '7': 'QSymmS16',
  '8': 'QAsymmS8',
  '9': 'QSymmS8'
};

/**
 * @enum {number}
 */
armnnSerializer.DataLayout = {
  NHWC: 0,
  NCHW: 1
};

/**
 * @enum {string}
 */
armnnSerializer.DataLayoutName = {
  '0': 'NHWC',
  '1': 'NCHW'
};

/**
 * @enum {number}
 */
armnnSerializer.ResizeMethod = {
  NearestNeighbor: 0,
  Bilinear: 1
};

/**
 * @enum {string}
 */
armnnSerializer.ResizeMethodName = {
  '0': 'NearestNeighbor',
  '1': 'Bilinear'
};

/**
 * @enum {number}
 */
armnnSerializer.ConstTensorData = {
  NONE: 0,
  ByteData: 1,
  ShortData: 2,
  IntData: 3,
  LongData: 4
};

/**
 * @enum {string}
 */
armnnSerializer.ConstTensorDataName = {
  '0': 'NONE',
  '1': 'ByteData',
  '2': 'ShortData',
  '3': 'IntData',
  '4': 'LongData'
};

/**
 * @enum {number}
 */
armnnSerializer.LayerType = {
  Addition: 0,
  Input: 1,
  Multiplication: 2,
  Output: 3,
  Pooling2d: 4,
  Reshape: 5,
  Softmax: 6,
  Convolution2d: 7,
  DepthwiseConvolution2d: 8,
  Activation: 9,
  Permute: 10,
  FullyConnected: 11,
  Constant: 12,
  SpaceToBatchNd: 13,
  BatchToSpaceNd: 14,
  Division: 15,
  Minimum: 16,
  Equal: 17,
  Maximum: 18,
  Normalization: 19,
  Pad: 20,
  Rsqrt: 21,
  Floor: 22,
  BatchNormalization: 23,
  Greater: 24,
  ResizeBilinear: 25,
  Subtraction: 26,
  StridedSlice: 27,
  Gather: 28,
  Mean: 29,
  Merger: 30,
  L2Normalization: 31,
  Splitter: 32,
  DetectionPostProcess: 33,
  Lstm: 34,
  Quantize: 35,
  Dequantize: 36,
  Merge: 37,
  Switch: 38,
  Concat: 39,
  SpaceToDepth: 40,
  Prelu: 41,
  TransposeConvolution2d: 42,
  Resize: 43,
  Stack: 44,
  QuantizedLstm: 45,
  Abs: 46,
  ArgMinMax: 47,
  Slice: 48,
  DepthToSpace: 49,
  InstanceNormalization: 50,
  LogSoftmax: 51,
  Comparison: 52,
  StandIn: 53,
  ElementwiseUnary: 54,
  Transpose: 55
};

/**
 * @enum {string}
 */
armnnSerializer.LayerTypeName = {
  '0': 'Addition',
  '1': 'Input',
  '2': 'Multiplication',
  '3': 'Output',
  '4': 'Pooling2d',
  '5': 'Reshape',
  '6': 'Softmax',
  '7': 'Convolution2d',
  '8': 'DepthwiseConvolution2d',
  '9': 'Activation',
  '10': 'Permute',
  '11': 'FullyConnected',
  '12': 'Constant',
  '13': 'SpaceToBatchNd',
  '14': 'BatchToSpaceNd',
  '15': 'Division',
  '16': 'Minimum',
  '17': 'Equal',
  '18': 'Maximum',
  '19': 'Normalization',
  '20': 'Pad',
  '21': 'Rsqrt',
  '22': 'Floor',
  '23': 'BatchNormalization',
  '24': 'Greater',
  '25': 'ResizeBilinear',
  '26': 'Subtraction',
  '27': 'StridedSlice',
  '28': 'Gather',
  '29': 'Mean',
  '30': 'Merger',
  '31': 'L2Normalization',
  '32': 'Splitter',
  '33': 'DetectionPostProcess',
  '34': 'Lstm',
  '35': 'Quantize',
  '36': 'Dequantize',
  '37': 'Merge',
  '38': 'Switch',
  '39': 'Concat',
  '40': 'SpaceToDepth',
  '41': 'Prelu',
  '42': 'TransposeConvolution2d',
  '43': 'Resize',
  '44': 'Stack',
  '45': 'QuantizedLstm',
  '46': 'Abs',
  '47': 'ArgMinMax',
  '48': 'Slice',
  '49': 'DepthToSpace',
  '50': 'InstanceNormalization',
  '51': 'LogSoftmax',
  '52': 'Comparison',
  '53': 'StandIn',
  '54': 'ElementwiseUnary',
  '55': 'Transpose'
};

/**
 * @enum {number}
 */
armnnSerializer.ComparisonOperation = {
  Equal: 0,
  Greater: 1,
  GreaterOrEqual: 2,
  Less: 3,
  LessOrEqual: 4,
  NotEqual: 5
};

/**
 * @enum {string}
 */
armnnSerializer.ComparisonOperationName = {
  '0': 'Equal',
  '1': 'Greater',
  '2': 'GreaterOrEqual',
  '3': 'Less',
  '4': 'LessOrEqual',
  '5': 'NotEqual'
};

/**
 * @enum {number}
 */
armnnSerializer.UnaryOperation = {
  Abs: 0,
  Rsqrt: 1,
  Sqrt: 2,
  Exp: 3,
  Neg: 4
};

/**
 * @enum {string}
 */
armnnSerializer.UnaryOperationName = {
  '0': 'Abs',
  '1': 'Rsqrt',
  '2': 'Sqrt',
  '3': 'Exp',
  '4': 'Neg'
};

/**
 * @enum {number}
 */
armnnSerializer.PoolingAlgorithm = {
  Max: 0,
  Average: 1,
  L2: 2
};

/**
 * @enum {string}
 */
armnnSerializer.PoolingAlgorithmName = {
  '0': 'Max',
  '1': 'Average',
  '2': 'L2'
};

/**
 * @enum {number}
 */
armnnSerializer.OutputShapeRounding = {
  Floor: 0,
  Ceiling: 1
};

/**
 * @enum {string}
 */
armnnSerializer.OutputShapeRoundingName = {
  '0': 'Floor',
  '1': 'Ceiling'
};

/**
 * @enum {number}
 */
armnnSerializer.PaddingMethod = {
  IgnoreValue: 0,
  Exclude: 1
};

/**
 * @enum {string}
 */
armnnSerializer.PaddingMethodName = {
  '0': 'IgnoreValue',
  '1': 'Exclude'
};

/**
 * @enum {number}
 */
armnnSerializer.NormalizationAlgorithmChannel = {
  Across: 0,
  Within: 1
};

/**
 * @enum {string}
 */
armnnSerializer.NormalizationAlgorithmChannelName = {
  '0': 'Across',
  '1': 'Within'
};

/**
 * @enum {number}
 */
armnnSerializer.NormalizationAlgorithmMethod = {
  LocalBrightness: 0,
  LocalContrast: 1
};

/**
 * @enum {string}
 */
armnnSerializer.NormalizationAlgorithmMethodName = {
  '0': 'LocalBrightness',
  '1': 'LocalContrast'
};

/**
 * @enum {number}
 */
armnnSerializer.Layer = {
  NONE: 0,
  ActivationLayer: 1,
  AdditionLayer: 2,
  BatchToSpaceNdLayer: 3,
  BatchNormalizationLayer: 4,
  ConstantLayer: 5,
  Convolution2dLayer: 6,
  DepthwiseConvolution2dLayer: 7,
  FullyConnectedLayer: 8,
  InputLayer: 9,
  MultiplicationLayer: 10,
  OutputLayer: 11,
  PermuteLayer: 12,
  Pooling2dLayer: 13,
  ReshapeLayer: 14,
  SoftmaxLayer: 15,
  SpaceToBatchNdLayer: 16,
  DivisionLayer: 17,
  MinimumLayer: 18,
  EqualLayer: 19,
  MaximumLayer: 20,
  NormalizationLayer: 21,
  PadLayer: 22,
  RsqrtLayer: 23,
  FloorLayer: 24,
  GreaterLayer: 25,
  ResizeBilinearLayer: 26,
  SubtractionLayer: 27,
  StridedSliceLayer: 28,
  GatherLayer: 29,
  MeanLayer: 30,
  MergerLayer: 31,
  L2NormalizationLayer: 32,
  SplitterLayer: 33,
  DetectionPostProcessLayer: 34,
  LstmLayer: 35,
  QuantizedLstmLayer: 36,
  QuantizeLayer: 37,
  DequantizeLayer: 38,
  MergeLayer: 39,
  SwitchLayer: 40,
  ConcatLayer: 41,
  SpaceToDepthLayer: 42,
  PreluLayer: 43,
  TransposeConvolution2dLayer: 44,
  ResizeLayer: 45,
  StackLayer: 46,
  AbsLayer: 47,
  ArgMinMaxLayer: 48,
  SliceLayer: 49,
  DepthToSpaceLayer: 50,
  InstanceNormalizationLayer: 51,
  LogSoftmaxLayer: 52,
  ComparisonLayer: 53,
  StandInLayer: 54,
  ElementwiseUnaryLayer: 55,
  TransposeLayer: 56
};

/**
 * @enum {string}
 */
armnnSerializer.LayerName = {
  '0': 'NONE',
  '1': 'ActivationLayer',
  '2': 'AdditionLayer',
  '3': 'BatchToSpaceNdLayer',
  '4': 'BatchNormalizationLayer',
  '5': 'ConstantLayer',
  '6': 'Convolution2dLayer',
  '7': 'DepthwiseConvolution2dLayer',
  '8': 'FullyConnectedLayer',
  '9': 'InputLayer',
  '10': 'MultiplicationLayer',
  '11': 'OutputLayer',
  '12': 'PermuteLayer',
  '13': 'Pooling2dLayer',
  '14': 'ReshapeLayer',
  '15': 'SoftmaxLayer',
  '16': 'SpaceToBatchNdLayer',
  '17': 'DivisionLayer',
  '18': 'MinimumLayer',
  '19': 'EqualLayer',
  '20': 'MaximumLayer',
  '21': 'NormalizationLayer',
  '22': 'PadLayer',
  '23': 'RsqrtLayer',
  '24': 'FloorLayer',
  '25': 'GreaterLayer',
  '26': 'ResizeBilinearLayer',
  '27': 'SubtractionLayer',
  '28': 'StridedSliceLayer',
  '29': 'GatherLayer',
  '30': 'MeanLayer',
  '31': 'MergerLayer',
  '32': 'L2NormalizationLayer',
  '33': 'SplitterLayer',
  '34': 'DetectionPostProcessLayer',
  '35': 'LstmLayer',
  '36': 'QuantizedLstmLayer',
  '37': 'QuantizeLayer',
  '38': 'DequantizeLayer',
  '39': 'MergeLayer',
  '40': 'SwitchLayer',
  '41': 'ConcatLayer',
  '42': 'SpaceToDepthLayer',
  '43': 'PreluLayer',
  '44': 'TransposeConvolution2dLayer',
  '45': 'ResizeLayer',
  '46': 'StackLayer',
  '47': 'AbsLayer',
  '48': 'ArgMinMaxLayer',
  '49': 'SliceLayer',
  '50': 'DepthToSpaceLayer',
  '51': 'InstanceNormalizationLayer',
  '52': 'LogSoftmaxLayer',
  '53': 'ComparisonLayer',
  '54': 'StandInLayer',
  '55': 'ElementwiseUnaryLayer',
  '56': 'TransposeLayer'
};

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.TensorInfo.prototype.dimensions = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @returns {armnnSerializer.DataType}
 */
armnnSerializer.TensorInfo.prototype.dataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.DataType} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataType.Float16;
};

/**
 * @returns {number}
 */
armnnSerializer.TensorInfo.prototype.quantizationScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 1.0;
};

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.TensorInfo.prototype.quantizationDim = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.TensorInfo.startTensorInfo = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimensionsOffset
 */
armnnSerializer.TensorInfo.addDimensions = function(builder, dimensionsOffset) {
  builder.addFieldOffset(0, dimensionsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataType} dataType
 */
armnnSerializer.TensorInfo.addDataType = function(builder, dataType) {
  builder.addFieldInt8(1, dataType, armnnSerializer.DataType.Float16);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantizationScale
 */
armnnSerializer.TensorInfo.addQuantizationScale = function(builder, quantizationScale) {
  builder.addFieldFloat32(2, quantizationScale, 1.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantizationOffset
 */
armnnSerializer.TensorInfo.addQuantizationOffset = function(builder, quantizationOffset) {
  builder.addFieldInt32(3, quantizationOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} quantizationScalesOffset
 */
armnnSerializer.TensorInfo.addQuantizationScales = function(builder, quantizationScalesOffset) {
  builder.addFieldOffset(4, quantizationScalesOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantizationDim
 */
armnnSerializer.TensorInfo.addQuantizationDim = function(builder, quantizationDim) {
  builder.addFieldInt32(5, quantizationDim, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TensorInfo.endTensorInfo = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimensionsOffset
 * @param {armnnSerializer.DataType} dataType
 * @param {number} quantizationScale
 * @param {number} quantizationOffset
 * @param {flatbuffers.Offset} quantizationScalesOffset
 * @param {number} quantizationDim
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TensorInfo.createTensorInfo = function(builder, dimensionsOffset, dataType, quantizationScale, quantizationOffset, quantizationScalesOffset, quantizationDim) {
  armnnSerializer.TensorInfo.startTensorInfo(builder);
  armnnSerializer.TensorInfo.addDimensions(builder, dimensionsOffset);
  armnnSerializer.TensorInfo.addDataType(builder, dataType);
  armnnSerializer.TensorInfo.addQuantizationScale(builder, quantizationScale);
  armnnSerializer.TensorInfo.addQuantizationOffset(builder, quantizationOffset);
  armnnSerializer.TensorInfo.addQuantizationScales(builder, quantizationScalesOffset);
  armnnSerializer.TensorInfo.addQuantizationDim(builder, quantizationDim);
  return armnnSerializer.TensorInfo.endTensorInfo(builder);
}

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.Connection.prototype.sourceLayerIndex = function() {
  return this.bb.readUint32(this.bb_pos);
};

/**
 * @returns {number}
 */
armnnSerializer.Connection.prototype.outputSlotIndex = function() {
  return this.bb.readUint32(this.bb_pos + 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} sourceLayerIndex
 * @param {number} outputSlotIndex
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Connection.createConnection = function(builder, sourceLayerIndex, outputSlotIndex) {
  builder.prep(4, 8);
  builder.writeInt32(outputSlotIndex);
  builder.writeInt32(sourceLayerIndex);
  return builder.offset();
};

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

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ByteData.startByteData = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.ByteData.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ByteData.endByteData = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ByteData.createByteData = function(builder, dataOffset) {
  armnnSerializer.ByteData.startByteData(builder);
  armnnSerializer.ByteData.addData(builder, dataOffset);
  return armnnSerializer.ByteData.endByteData(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.ShortData.prototype.data = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt16(this.bb.__vector(this.bb_pos + offset) + index * 2) : 0;
};

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

/**
 * @returns {Int16Array}
 */
armnnSerializer.ShortData.prototype.dataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int16Array(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
 */
armnnSerializer.ShortData.startShortData = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.ShortData.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ShortData.createDataVector = 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
 */
armnnSerializer.ShortData.startDataVector = function(builder, numElems) {
  builder.startVector(2, numElems, 2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ShortData.endShortData = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ShortData.createShortData = function(builder, dataOffset) {
  armnnSerializer.ShortData.startShortData(builder);
  armnnSerializer.ShortData.addData(builder, dataOffset);
  return armnnSerializer.ShortData.endShortData(builder);
}

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

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

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

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

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

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

/**
 * @returns {Int32Array}
 */
armnnSerializer.IntData.prototype.dataArray = 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
 */
armnnSerializer.IntData.startIntData = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.IntData.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.IntData.endIntData = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.IntData.createIntData = function(builder, dataOffset) {
  armnnSerializer.IntData.startIntData(builder);
  armnnSerializer.IntData.addData(builder, dataOffset);
  return armnnSerializer.IntData.endIntData(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LongData.startLongData = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.LongData.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LongData.endLongData = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LongData.createLongData = function(builder, dataOffset) {
  armnnSerializer.LongData.startLongData(builder);
  armnnSerializer.LongData.addData(builder, dataOffset);
  return armnnSerializer.LongData.endLongData(builder);
}

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.ConstTensorData}
 */
armnnSerializer.ConstTensor.prototype.dataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.ConstTensorData} */ (this.bb.readUint8(this.bb_pos + offset)) : armnnSerializer.ConstTensorData.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
armnnSerializer.ConstTensor.prototype.data = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ConstTensor.startConstTensor = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} infoOffset
 */
armnnSerializer.ConstTensor.addInfo = function(builder, infoOffset) {
  builder.addFieldOffset(0, infoOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ConstTensorData} dataType
 */
armnnSerializer.ConstTensor.addDataType = function(builder, dataType) {
  builder.addFieldInt8(1, dataType, armnnSerializer.ConstTensorData.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.ConstTensor.addData = function(builder, dataOffset) {
  builder.addFieldOffset(2, dataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConstTensor.endConstTensor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} infoOffset
 * @param {armnnSerializer.ConstTensorData} dataType
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConstTensor.createConstTensor = function(builder, infoOffset, dataType, dataOffset) {
  armnnSerializer.ConstTensor.startConstTensor(builder);
  armnnSerializer.ConstTensor.addInfo(builder, infoOffset);
  armnnSerializer.ConstTensor.addDataType(builder, dataType);
  armnnSerializer.ConstTensor.addData(builder, dataOffset);
  return armnnSerializer.ConstTensor.endConstTensor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.Connection=} obj
 * @returns {armnnSerializer.Connection|null}
 */
armnnSerializer.InputSlot.prototype.connection = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.Connection).__init(this.bb_pos + offset, this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.InputSlot.startInputSlot = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 */
armnnSerializer.InputSlot.addIndex = function(builder, index) {
  builder.addFieldInt32(0, index, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} connectionOffset
 */
armnnSerializer.InputSlot.addConnection = function(builder, connectionOffset) {
  builder.addFieldStruct(1, connectionOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InputSlot.endInputSlot = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 * @param {flatbuffers.Offset} connectionOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InputSlot.createInputSlot = function(builder, index, connectionOffset) {
  armnnSerializer.InputSlot.startInputSlot(builder);
  armnnSerializer.InputSlot.addIndex(builder, index);
  armnnSerializer.InputSlot.addConnection(builder, connectionOffset);
  return armnnSerializer.InputSlot.endInputSlot(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.TensorInfo=} obj
 * @returns {armnnSerializer.TensorInfo|null}
 */
armnnSerializer.OutputSlot.prototype.tensorInfo = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.TensorInfo).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.OutputSlot.startOutputSlot = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 */
armnnSerializer.OutputSlot.addIndex = function(builder, index) {
  builder.addFieldInt32(0, index, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorInfoOffset
 */
armnnSerializer.OutputSlot.addTensorInfo = function(builder, tensorInfoOffset) {
  builder.addFieldOffset(1, tensorInfoOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OutputSlot.endOutputSlot = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 * @param {flatbuffers.Offset} tensorInfoOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OutputSlot.createOutputSlot = function(builder, index, tensorInfoOffset) {
  armnnSerializer.OutputSlot.startOutputSlot(builder);
  armnnSerializer.OutputSlot.addIndex(builder, index);
  armnnSerializer.OutputSlot.addTensorInfo(builder, tensorInfoOffset);
  return armnnSerializer.OutputSlot.endOutputSlot(builder);
}

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

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.LayerType}
 */
armnnSerializer.LayerBase.prototype.layerType = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {armnnSerializer.LayerType} */ (this.bb.readUint32(this.bb_pos + offset)) : armnnSerializer.LayerType.Addition;
};

/**
 * @param {number} index
 * @param {armnnSerializer.InputSlot=} obj
 * @returns {armnnSerializer.InputSlot}
 */
armnnSerializer.LayerBase.prototype.inputSlots = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new armnnSerializer.InputSlot).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {number} index
 * @param {armnnSerializer.OutputSlot=} obj
 * @returns {armnnSerializer.OutputSlot}
 */
armnnSerializer.LayerBase.prototype.outputSlots = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new armnnSerializer.OutputSlot).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LayerBase.startLayerBase = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 */
armnnSerializer.LayerBase.addIndex = function(builder, index) {
  builder.addFieldInt32(0, index, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} layerNameOffset
 */
armnnSerializer.LayerBase.addLayerName = function(builder, layerNameOffset) {
  builder.addFieldOffset(1, layerNameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.LayerType} layerType
 */
armnnSerializer.LayerBase.addLayerType = function(builder, layerType) {
  builder.addFieldInt32(2, layerType, armnnSerializer.LayerType.Addition);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputSlotsOffset
 */
armnnSerializer.LayerBase.addInputSlots = function(builder, inputSlotsOffset) {
  builder.addFieldOffset(3, inputSlotsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LayerBase.createInputSlotsVector = 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
 */
armnnSerializer.LayerBase.startInputSlotsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputSlotsOffset
 */
armnnSerializer.LayerBase.addOutputSlots = function(builder, outputSlotsOffset) {
  builder.addFieldOffset(4, outputSlotsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LayerBase.createOutputSlotsVector = 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
 */
armnnSerializer.LayerBase.startOutputSlotsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LayerBase.endLayerBase = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 * @param {flatbuffers.Offset} layerNameOffset
 * @param {armnnSerializer.LayerType} layerType
 * @param {flatbuffers.Offset} inputSlotsOffset
 * @param {flatbuffers.Offset} outputSlotsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LayerBase.createLayerBase = function(builder, index, layerNameOffset, layerType, inputSlotsOffset, outputSlotsOffset) {
  armnnSerializer.LayerBase.startLayerBase(builder);
  armnnSerializer.LayerBase.addIndex(builder, index);
  armnnSerializer.LayerBase.addLayerName(builder, layerNameOffset);
  armnnSerializer.LayerBase.addLayerType(builder, layerType);
  armnnSerializer.LayerBase.addInputSlots(builder, inputSlotsOffset);
  armnnSerializer.LayerBase.addOutputSlots(builder, outputSlotsOffset);
  return armnnSerializer.LayerBase.endLayerBase(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.BindableLayerBase.startBindableLayerBase = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.BindableLayerBase.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} layerBindingId
 */
armnnSerializer.BindableLayerBase.addLayerBindingId = function(builder, layerBindingId) {
  builder.addFieldInt32(1, layerBindingId, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BindableLayerBase.endBindableLayerBase = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {number} layerBindingId
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BindableLayerBase.createBindableLayerBase = function(builder, baseOffset, layerBindingId) {
  armnnSerializer.BindableLayerBase.startBindableLayerBase(builder);
  armnnSerializer.BindableLayerBase.addBase(builder, baseOffset);
  armnnSerializer.BindableLayerBase.addLayerBindingId(builder, layerBindingId);
  return armnnSerializer.BindableLayerBase.endBindableLayerBase(builder);
}

/**
 * @deprecated Use ElementwiseUnaryLayer instead
 *
 * @constructor
 */
armnnSerializer.AbsLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.AbsLayer.startAbsLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.AbsLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AbsLayer.endAbsLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AbsLayer.createAbsLayer = function(builder, baseOffset) {
  armnnSerializer.AbsLayer.startAbsLayer(builder);
  armnnSerializer.AbsLayer.addBase(builder, baseOffset);
  return armnnSerializer.AbsLayer.endAbsLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ActivationDescriptor=} obj
 * @returns {armnnSerializer.ActivationDescriptor|null}
 */
armnnSerializer.ActivationLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ActivationDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ActivationLayer.startActivationLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ActivationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ActivationLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ActivationLayer.endActivationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ActivationLayer.createActivationLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ActivationLayer.startActivationLayer(builder);
  armnnSerializer.ActivationLayer.addBase(builder, baseOffset);
  armnnSerializer.ActivationLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ActivationLayer.endActivationLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.ActivationFunction}
 */
armnnSerializer.ActivationDescriptor.prototype.activationFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.ActivationFunction} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.ActivationFunction.Sigmoid;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ActivationDescriptor.startActivationDescriptor = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ActivationFunction} activationFunction
 */
armnnSerializer.ActivationDescriptor.addActivationFunction = function(builder, activationFunction) {
  builder.addFieldInt8(0, activationFunction, armnnSerializer.ActivationFunction.Sigmoid);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} a
 */
armnnSerializer.ActivationDescriptor.addA = function(builder, a) {
  builder.addFieldFloat32(1, a, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} b
 */
armnnSerializer.ActivationDescriptor.addB = function(builder, b) {
  builder.addFieldFloat32(2, b, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ActivationDescriptor.endActivationDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ActivationFunction} activationFunction
 * @param {number} a
 * @param {number} b
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ActivationDescriptor.createActivationDescriptor = function(builder, activationFunction, a, b) {
  armnnSerializer.ActivationDescriptor.startActivationDescriptor(builder);
  armnnSerializer.ActivationDescriptor.addActivationFunction(builder, activationFunction);
  armnnSerializer.ActivationDescriptor.addA(builder, a);
  armnnSerializer.ActivationDescriptor.addB(builder, b);
  return armnnSerializer.ActivationDescriptor.endActivationDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.AdditionLayer.startAdditionLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.AdditionLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AdditionLayer.endAdditionLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AdditionLayer.createAdditionLayer = function(builder, baseOffset) {
  armnnSerializer.AdditionLayer.startAdditionLayer(builder);
  armnnSerializer.AdditionLayer.addBase(builder, baseOffset);
  return armnnSerializer.AdditionLayer.endAdditionLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ArgMinMaxDescriptor=} obj
 * @returns {armnnSerializer.ArgMinMaxDescriptor|null}
 */
armnnSerializer.ArgMinMaxLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ArgMinMaxDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ArgMinMaxLayer.startArgMinMaxLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ArgMinMaxLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ArgMinMaxLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ArgMinMaxLayer.endArgMinMaxLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ArgMinMaxLayer.createArgMinMaxLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ArgMinMaxLayer.startArgMinMaxLayer(builder);
  armnnSerializer.ArgMinMaxLayer.addBase(builder, baseOffset);
  armnnSerializer.ArgMinMaxLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ArgMinMaxLayer.endArgMinMaxLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.ArgMinMaxFunction}
 */
armnnSerializer.ArgMinMaxDescriptor.prototype.argMinMaxFunction = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.ArgMinMaxFunction} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.ArgMinMaxFunction.Min;
};

/**
 * @returns {number}
 */
armnnSerializer.ArgMinMaxDescriptor.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
 */
armnnSerializer.ArgMinMaxDescriptor.startArgMinMaxDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ArgMinMaxFunction} argMinMaxFunction
 */
armnnSerializer.ArgMinMaxDescriptor.addArgMinMaxFunction = function(builder, argMinMaxFunction) {
  builder.addFieldInt8(0, argMinMaxFunction, armnnSerializer.ArgMinMaxFunction.Min);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ArgMinMaxDescriptor.endArgMinMaxDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ArgMinMaxFunction} argMinMaxFunction
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ArgMinMaxDescriptor.createArgMinMaxDescriptor = function(builder, argMinMaxFunction, axis) {
  armnnSerializer.ArgMinMaxDescriptor.startArgMinMaxDescriptor(builder);
  armnnSerializer.ArgMinMaxDescriptor.addArgMinMaxFunction(builder, argMinMaxFunction);
  armnnSerializer.ArgMinMaxDescriptor.addAxis(builder, axis);
  return armnnSerializer.ArgMinMaxDescriptor.endArgMinMaxDescriptor(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.ComparisonOperation}
 */
armnnSerializer.ComparisonDescriptor.prototype.operation = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.ComparisonOperation} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.ComparisonOperation.Equal;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ComparisonDescriptor.startComparisonDescriptor = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ComparisonOperation} operation
 */
armnnSerializer.ComparisonDescriptor.addOperation = function(builder, operation) {
  builder.addFieldInt8(0, operation, armnnSerializer.ComparisonOperation.Equal);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ComparisonDescriptor.endComparisonDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ComparisonOperation} operation
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ComparisonDescriptor.createComparisonDescriptor = function(builder, operation) {
  armnnSerializer.ComparisonDescriptor.startComparisonDescriptor(builder);
  armnnSerializer.ComparisonDescriptor.addOperation(builder, operation);
  return armnnSerializer.ComparisonDescriptor.endComparisonDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ComparisonDescriptor=} obj
 * @returns {armnnSerializer.ComparisonDescriptor|null}
 */
armnnSerializer.ComparisonLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ComparisonDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ComparisonLayer.startComparisonLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ComparisonLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ComparisonLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ComparisonLayer.endComparisonLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ComparisonLayer.createComparisonLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ComparisonLayer.startComparisonLayer(builder);
  armnnSerializer.ComparisonLayer.addBase(builder, baseOffset);
  armnnSerializer.ComparisonLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ComparisonLayer.endComparisonLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.ConstantLayer.prototype.input = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ConstantLayer.startConstantLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ConstantLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputOffset
 */
armnnSerializer.ConstantLayer.addInput = function(builder, inputOffset) {
  builder.addFieldOffset(1, inputOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConstantLayer.endConstantLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} inputOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConstantLayer.createConstantLayer = function(builder, baseOffset, inputOffset) {
  armnnSerializer.ConstantLayer.startConstantLayer(builder);
  armnnSerializer.ConstantLayer.addBase(builder, baseOffset);
  armnnSerializer.ConstantLayer.addInput(builder, inputOffset);
  return armnnSerializer.ConstantLayer.endConstantLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.Convolution2dDescriptor=} obj
 * @returns {armnnSerializer.Convolution2dDescriptor|null}
 */
armnnSerializer.Convolution2dLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.Convolution2dDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.Convolution2dLayer.prototype.weights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.Convolution2dLayer.startConvolution2dLayer = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.Convolution2dLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.Convolution2dLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightsOffset
 */
armnnSerializer.Convolution2dLayer.addWeights = function(builder, weightsOffset) {
  builder.addFieldOffset(2, weightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasesOffset
 */
armnnSerializer.Convolution2dLayer.addBiases = function(builder, biasesOffset) {
  builder.addFieldOffset(3, biasesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Convolution2dLayer.endConvolution2dLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} weightsOffset
 * @param {flatbuffers.Offset} biasesOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Convolution2dLayer.createConvolution2dLayer = function(builder, baseOffset, descriptorOffset, weightsOffset, biasesOffset) {
  armnnSerializer.Convolution2dLayer.startConvolution2dLayer(builder);
  armnnSerializer.Convolution2dLayer.addBase(builder, baseOffset);
  armnnSerializer.Convolution2dLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.Convolution2dLayer.addWeights(builder, weightsOffset);
  armnnSerializer.Convolution2dLayer.addBiases(builder, biasesOffset);
  return armnnSerializer.Convolution2dLayer.endConvolution2dLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.padRight = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.padBottom = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.dilationX = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
armnnSerializer.Convolution2dDescriptor.prototype.dilationY = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 1;
};

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.Convolution2dDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.Convolution2dDescriptor.startConvolution2dDescriptor = function(builder) {
  builder.startObject(10);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 */
armnnSerializer.Convolution2dDescriptor.addPadLeft = function(builder, padLeft) {
  builder.addFieldInt32(0, padLeft, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padRight
 */
armnnSerializer.Convolution2dDescriptor.addPadRight = function(builder, padRight) {
  builder.addFieldInt32(1, padRight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padTop
 */
armnnSerializer.Convolution2dDescriptor.addPadTop = function(builder, padTop) {
  builder.addFieldInt32(2, padTop, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padBottom
 */
armnnSerializer.Convolution2dDescriptor.addPadBottom = function(builder, padBottom) {
  builder.addFieldInt32(3, padBottom, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
armnnSerializer.Convolution2dDescriptor.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(4, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
armnnSerializer.Convolution2dDescriptor.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(5, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationX
 */
armnnSerializer.Convolution2dDescriptor.addDilationX = function(builder, dilationX) {
  builder.addFieldInt32(6, dilationX, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationY
 */
armnnSerializer.Convolution2dDescriptor.addDilationY = function(builder, dilationY) {
  builder.addFieldInt32(7, dilationY, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasEnabled
 */
armnnSerializer.Convolution2dDescriptor.addBiasEnabled = function(builder, biasEnabled) {
  builder.addFieldInt8(8, +biasEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.Convolution2dDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(9, dataLayout, armnnSerializer.DataLayout.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Convolution2dDescriptor.endConvolution2dDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 * @param {number} padRight
 * @param {number} padTop
 * @param {number} padBottom
 * @param {number} strideX
 * @param {number} strideY
 * @param {number} dilationX
 * @param {number} dilationY
 * @param {boolean} biasEnabled
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Convolution2dDescriptor.createConvolution2dDescriptor = function(builder, padLeft, padRight, padTop, padBottom, strideX, strideY, dilationX, dilationY, biasEnabled, dataLayout) {
  armnnSerializer.Convolution2dDescriptor.startConvolution2dDescriptor(builder);
  armnnSerializer.Convolution2dDescriptor.addPadLeft(builder, padLeft);
  armnnSerializer.Convolution2dDescriptor.addPadRight(builder, padRight);
  armnnSerializer.Convolution2dDescriptor.addPadTop(builder, padTop);
  armnnSerializer.Convolution2dDescriptor.addPadBottom(builder, padBottom);
  armnnSerializer.Convolution2dDescriptor.addStrideX(builder, strideX);
  armnnSerializer.Convolution2dDescriptor.addStrideY(builder, strideY);
  armnnSerializer.Convolution2dDescriptor.addDilationX(builder, dilationX);
  armnnSerializer.Convolution2dDescriptor.addDilationY(builder, dilationY);
  armnnSerializer.Convolution2dDescriptor.addBiasEnabled(builder, biasEnabled);
  armnnSerializer.Convolution2dDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.Convolution2dDescriptor.endConvolution2dDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.DepthToSpaceDescriptor=} obj
 * @returns {armnnSerializer.DepthToSpaceDescriptor|null}
 */
armnnSerializer.DepthToSpaceLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.DepthToSpaceDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DepthToSpaceLayer.startDepthToSpaceLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.DepthToSpaceLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.DepthToSpaceLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthToSpaceLayer.endDepthToSpaceLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthToSpaceLayer.createDepthToSpaceLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.DepthToSpaceLayer.startDepthToSpaceLayer(builder);
  armnnSerializer.DepthToSpaceLayer.addBase(builder, baseOffset);
  armnnSerializer.DepthToSpaceLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.DepthToSpaceLayer.endDepthToSpaceLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.DepthToSpaceDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DepthToSpaceDescriptor.startDepthToSpaceDescriptor = function(builder) {
  builder.startObject(2);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.DepthToSpaceDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(1, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthToSpaceDescriptor.endDepthToSpaceDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthToSpaceDescriptor.createDepthToSpaceDescriptor = function(builder, blockSize, dataLayout) {
  armnnSerializer.DepthToSpaceDescriptor.startDepthToSpaceDescriptor(builder);
  armnnSerializer.DepthToSpaceDescriptor.addBlockSize(builder, blockSize);
  armnnSerializer.DepthToSpaceDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.DepthToSpaceDescriptor.endDepthToSpaceDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DivisionLayer.startDivisionLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.DivisionLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DivisionLayer.endDivisionLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DivisionLayer.createDivisionLayer = function(builder, baseOffset) {
  armnnSerializer.DivisionLayer.startDivisionLayer(builder);
  armnnSerializer.DivisionLayer.addBase(builder, baseOffset);
  return armnnSerializer.DivisionLayer.endDivisionLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.UnaryOperation}
 */
armnnSerializer.ElementwiseUnaryDescriptor.prototype.operation = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.UnaryOperation} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.UnaryOperation.Abs;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ElementwiseUnaryDescriptor.startElementwiseUnaryDescriptor = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.UnaryOperation} operation
 */
armnnSerializer.ElementwiseUnaryDescriptor.addOperation = function(builder, operation) {
  builder.addFieldInt8(0, operation, armnnSerializer.UnaryOperation.Abs);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ElementwiseUnaryDescriptor.endElementwiseUnaryDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.UnaryOperation} operation
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ElementwiseUnaryDescriptor.createElementwiseUnaryDescriptor = function(builder, operation) {
  armnnSerializer.ElementwiseUnaryDescriptor.startElementwiseUnaryDescriptor(builder);
  armnnSerializer.ElementwiseUnaryDescriptor.addOperation(builder, operation);
  return armnnSerializer.ElementwiseUnaryDescriptor.endElementwiseUnaryDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ElementwiseUnaryDescriptor=} obj
 * @returns {armnnSerializer.ElementwiseUnaryDescriptor|null}
 */
armnnSerializer.ElementwiseUnaryLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ElementwiseUnaryDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ElementwiseUnaryLayer.startElementwiseUnaryLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ElementwiseUnaryLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ElementwiseUnaryLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ElementwiseUnaryLayer.endElementwiseUnaryLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ElementwiseUnaryLayer.createElementwiseUnaryLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ElementwiseUnaryLayer.startElementwiseUnaryLayer(builder);
  armnnSerializer.ElementwiseUnaryLayer.addBase(builder, baseOffset);
  armnnSerializer.ElementwiseUnaryLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ElementwiseUnaryLayer.endElementwiseUnaryLayer(builder);
}

/**
 * @deprecated Use ComparisonLayer instead
 *
 * @constructor
 */
armnnSerializer.EqualLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.EqualLayer.startEqualLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.EqualLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.EqualLayer.endEqualLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.EqualLayer.createEqualLayer = function(builder, baseOffset) {
  armnnSerializer.EqualLayer.startEqualLayer(builder);
  armnnSerializer.EqualLayer.addBase(builder, baseOffset);
  return armnnSerializer.EqualLayer.endEqualLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.FloorLayer.startFloorLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.FloorLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FloorLayer.endFloorLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FloorLayer.createFloorLayer = function(builder, baseOffset) {
  armnnSerializer.FloorLayer.startFloorLayer(builder);
  armnnSerializer.FloorLayer.addBase(builder, baseOffset);
  return armnnSerializer.FloorLayer.endFloorLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.FullyConnectedDescriptor=} obj
 * @returns {armnnSerializer.FullyConnectedDescriptor|null}
 */
armnnSerializer.FullyConnectedLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.FullyConnectedDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.FullyConnectedLayer.prototype.weights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.FullyConnectedLayer.startFullyConnectedLayer = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.FullyConnectedLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.FullyConnectedLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightsOffset
 */
armnnSerializer.FullyConnectedLayer.addWeights = function(builder, weightsOffset) {
  builder.addFieldOffset(2, weightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasesOffset
 */
armnnSerializer.FullyConnectedLayer.addBiases = function(builder, biasesOffset) {
  builder.addFieldOffset(3, biasesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FullyConnectedLayer.endFullyConnectedLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} weightsOffset
 * @param {flatbuffers.Offset} biasesOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FullyConnectedLayer.createFullyConnectedLayer = function(builder, baseOffset, descriptorOffset, weightsOffset, biasesOffset) {
  armnnSerializer.FullyConnectedLayer.startFullyConnectedLayer(builder);
  armnnSerializer.FullyConnectedLayer.addBase(builder, baseOffset);
  armnnSerializer.FullyConnectedLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.FullyConnectedLayer.addWeights(builder, weightsOffset);
  armnnSerializer.FullyConnectedLayer.addBiases(builder, biasesOffset);
  return armnnSerializer.FullyConnectedLayer.endFullyConnectedLayer(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.FullyConnectedDescriptor.startFullyConnectedDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasEnabled
 */
armnnSerializer.FullyConnectedDescriptor.addBiasEnabled = function(builder, biasEnabled) {
  builder.addFieldInt8(0, +biasEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeWeightsMatrix
 */
armnnSerializer.FullyConnectedDescriptor.addTransposeWeightsMatrix = function(builder, transposeWeightsMatrix) {
  builder.addFieldInt8(1, +transposeWeightsMatrix, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FullyConnectedDescriptor.endFullyConnectedDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasEnabled
 * @param {boolean} transposeWeightsMatrix
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FullyConnectedDescriptor.createFullyConnectedDescriptor = function(builder, biasEnabled, transposeWeightsMatrix) {
  armnnSerializer.FullyConnectedDescriptor.startFullyConnectedDescriptor(builder);
  armnnSerializer.FullyConnectedDescriptor.addBiasEnabled(builder, biasEnabled);
  armnnSerializer.FullyConnectedDescriptor.addTransposeWeightsMatrix(builder, transposeWeightsMatrix);
  return armnnSerializer.FullyConnectedDescriptor.endFullyConnectedDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.GatherLayer.startGatherLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.GatherLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.GatherLayer.endGatherLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.GatherLayer.createGatherLayer = function(builder, baseOffset) {
  armnnSerializer.GatherLayer.startGatherLayer(builder);
  armnnSerializer.GatherLayer.addBase(builder, baseOffset);
  return armnnSerializer.GatherLayer.endGatherLayer(builder);
}

/**
 * @deprecated Use ComparisonLayer instead
 *
 * @constructor
 */
armnnSerializer.GreaterLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.GreaterLayer.startGreaterLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.GreaterLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.GreaterLayer.endGreaterLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.GreaterLayer.createGreaterLayer = function(builder, baseOffset) {
  armnnSerializer.GreaterLayer.startGreaterLayer(builder);
  armnnSerializer.GreaterLayer.addBase(builder, baseOffset);
  return armnnSerializer.GreaterLayer.endGreaterLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.InputLayer.startInputLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.InputLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InputLayer.endInputLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InputLayer.createInputLayer = function(builder, baseOffset) {
  armnnSerializer.InputLayer.startInputLayer(builder);
  armnnSerializer.InputLayer.addBase(builder, baseOffset);
  return armnnSerializer.InputLayer.endInputLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.InstanceNormalizationDescriptor=} obj
 * @returns {armnnSerializer.InstanceNormalizationDescriptor|null}
 */
armnnSerializer.InstanceNormalizationLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.InstanceNormalizationDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.InstanceNormalizationLayer.startInstanceNormalizationLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.InstanceNormalizationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.InstanceNormalizationLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InstanceNormalizationLayer.endInstanceNormalizationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InstanceNormalizationLayer.createInstanceNormalizationLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.InstanceNormalizationLayer.startInstanceNormalizationLayer(builder);
  armnnSerializer.InstanceNormalizationLayer.addBase(builder, baseOffset);
  armnnSerializer.InstanceNormalizationLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.InstanceNormalizationLayer.endInstanceNormalizationLayer(builder);
}

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

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

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.InstanceNormalizationDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.InstanceNormalizationDescriptor.startInstanceNormalizationDescriptor = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} gamma
 */
armnnSerializer.InstanceNormalizationDescriptor.addGamma = function(builder, gamma) {
  builder.addFieldFloat32(0, gamma, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
armnnSerializer.InstanceNormalizationDescriptor.addBeta = function(builder, beta) {
  builder.addFieldFloat32(1, beta, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} eps
 */
armnnSerializer.InstanceNormalizationDescriptor.addEps = function(builder, eps) {
  builder.addFieldFloat32(2, eps, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.InstanceNormalizationDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(3, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InstanceNormalizationDescriptor.endInstanceNormalizationDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} gamma
 * @param {number} beta
 * @param {number} eps
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.InstanceNormalizationDescriptor.createInstanceNormalizationDescriptor = function(builder, gamma, beta, eps, dataLayout) {
  armnnSerializer.InstanceNormalizationDescriptor.startInstanceNormalizationDescriptor(builder);
  armnnSerializer.InstanceNormalizationDescriptor.addGamma(builder, gamma);
  armnnSerializer.InstanceNormalizationDescriptor.addBeta(builder, beta);
  armnnSerializer.InstanceNormalizationDescriptor.addEps(builder, eps);
  armnnSerializer.InstanceNormalizationDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.InstanceNormalizationDescriptor.endInstanceNormalizationDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.LogSoftmaxDescriptor=} obj
 * @returns {armnnSerializer.LogSoftmaxDescriptor|null}
 */
armnnSerializer.LogSoftmaxLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.LogSoftmaxDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LogSoftmaxLayer.startLogSoftmaxLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.LogSoftmaxLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.LogSoftmaxLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LogSoftmaxLayer.endLogSoftmaxLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LogSoftmaxLayer.createLogSoftmaxLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.LogSoftmaxLayer.startLogSoftmaxLayer(builder);
  armnnSerializer.LogSoftmaxLayer.addBase(builder, baseOffset);
  armnnSerializer.LogSoftmaxLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.LogSoftmaxLayer.endLogSoftmaxLayer(builder);
}

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.LogSoftmaxDescriptor.prototype.beta = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 1.0;
};

/**
 * @returns {number}
 */
armnnSerializer.LogSoftmaxDescriptor.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : -1;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LogSoftmaxDescriptor.startLogSoftmaxDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
armnnSerializer.LogSoftmaxDescriptor.addBeta = function(builder, beta) {
  builder.addFieldFloat32(0, beta, 1.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
armnnSerializer.LogSoftmaxDescriptor.addAxis = function(builder, axis) {
  builder.addFieldInt32(1, axis, -1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LogSoftmaxDescriptor.endLogSoftmaxDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LogSoftmaxDescriptor.createLogSoftmaxDescriptor = function(builder, beta, axis) {
  armnnSerializer.LogSoftmaxDescriptor.startLogSoftmaxDescriptor(builder);
  armnnSerializer.LogSoftmaxDescriptor.addBeta(builder, beta);
  armnnSerializer.LogSoftmaxDescriptor.addAxis(builder, axis);
  return armnnSerializer.LogSoftmaxDescriptor.endLogSoftmaxDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.L2NormalizationDescriptor=} obj
 * @returns {armnnSerializer.L2NormalizationDescriptor|null}
 */
armnnSerializer.L2NormalizationLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.L2NormalizationDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.L2NormalizationLayer.startL2NormalizationLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.L2NormalizationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.L2NormalizationLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.L2NormalizationLayer.endL2NormalizationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.L2NormalizationLayer.createL2NormalizationLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.L2NormalizationLayer.startL2NormalizationLayer(builder);
  armnnSerializer.L2NormalizationLayer.addBase(builder, baseOffset);
  armnnSerializer.L2NormalizationLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.L2NormalizationLayer.endL2NormalizationLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.L2NormalizationDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NCHW;
};

/**
 * @returns {number}
 */
armnnSerializer.L2NormalizationDescriptor.prototype.eps = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 1e-12;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.L2NormalizationDescriptor.startL2NormalizationDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.L2NormalizationDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(0, dataLayout, armnnSerializer.DataLayout.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} eps
 */
armnnSerializer.L2NormalizationDescriptor.addEps = function(builder, eps) {
  builder.addFieldFloat32(1, eps, 1e-12);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.L2NormalizationDescriptor.endL2NormalizationDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 * @param {number} eps
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.L2NormalizationDescriptor.createL2NormalizationDescriptor = function(builder, dataLayout, eps) {
  armnnSerializer.L2NormalizationDescriptor.startL2NormalizationDescriptor(builder);
  armnnSerializer.L2NormalizationDescriptor.addDataLayout(builder, dataLayout);
  armnnSerializer.L2NormalizationDescriptor.addEps(builder, eps);
  return armnnSerializer.L2NormalizationDescriptor.endL2NormalizationDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MinimumLayer.startMinimumLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MinimumLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MinimumLayer.endMinimumLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MinimumLayer.createMinimumLayer = function(builder, baseOffset) {
  armnnSerializer.MinimumLayer.startMinimumLayer(builder);
  armnnSerializer.MinimumLayer.addBase(builder, baseOffset);
  return armnnSerializer.MinimumLayer.endMinimumLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MaximumLayer.startMaximumLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MaximumLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MaximumLayer.endMaximumLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MaximumLayer.createMaximumLayer = function(builder, baseOffset) {
  armnnSerializer.MaximumLayer.startMaximumLayer(builder);
  armnnSerializer.MaximumLayer.addBase(builder, baseOffset);
  return armnnSerializer.MaximumLayer.endMaximumLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MultiplicationLayer.startMultiplicationLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MultiplicationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MultiplicationLayer.endMultiplicationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MultiplicationLayer.createMultiplicationLayer = function(builder, baseOffset) {
  armnnSerializer.MultiplicationLayer.startMultiplicationLayer(builder);
  armnnSerializer.MultiplicationLayer.addBase(builder, baseOffset);
  return armnnSerializer.MultiplicationLayer.endMultiplicationLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.Pooling2dDescriptor=} obj
 * @returns {armnnSerializer.Pooling2dDescriptor|null}
 */
armnnSerializer.Pooling2dLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.Pooling2dDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.Pooling2dLayer.startPooling2dLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.Pooling2dLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.Pooling2dLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Pooling2dLayer.endPooling2dLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Pooling2dLayer.createPooling2dLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.Pooling2dLayer.startPooling2dLayer(builder);
  armnnSerializer.Pooling2dLayer.addBase(builder, baseOffset);
  armnnSerializer.Pooling2dLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.Pooling2dLayer.endPooling2dLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.PoolingAlgorithm}
 */
armnnSerializer.Pooling2dDescriptor.prototype.poolType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.PoolingAlgorithm} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.PoolingAlgorithm.Max;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.padLeft = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.padTop = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.padBottom = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.poolWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.poolHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.Pooling2dDescriptor.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {armnnSerializer.OutputShapeRounding}
 */
armnnSerializer.Pooling2dDescriptor.prototype.outputShapeRounding = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? /** @type {armnnSerializer.OutputShapeRounding} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.OutputShapeRounding.Floor;
};

/**
 * @returns {armnnSerializer.PaddingMethod}
 */
armnnSerializer.Pooling2dDescriptor.prototype.paddingMethod = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? /** @type {armnnSerializer.PaddingMethod} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.PaddingMethod.IgnoreValue;
};

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.Pooling2dDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.Pooling2dDescriptor.startPooling2dDescriptor = function(builder) {
  builder.startObject(12);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.PoolingAlgorithm} poolType
 */
armnnSerializer.Pooling2dDescriptor.addPoolType = function(builder, poolType) {
  builder.addFieldInt8(0, poolType, armnnSerializer.PoolingAlgorithm.Max);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 */
armnnSerializer.Pooling2dDescriptor.addPadLeft = function(builder, padLeft) {
  builder.addFieldInt32(1, padLeft, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padRight
 */
armnnSerializer.Pooling2dDescriptor.addPadRight = function(builder, padRight) {
  builder.addFieldInt32(2, padRight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padTop
 */
armnnSerializer.Pooling2dDescriptor.addPadTop = function(builder, padTop) {
  builder.addFieldInt32(3, padTop, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padBottom
 */
armnnSerializer.Pooling2dDescriptor.addPadBottom = function(builder, padBottom) {
  builder.addFieldInt32(4, padBottom, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} poolWidth
 */
armnnSerializer.Pooling2dDescriptor.addPoolWidth = function(builder, poolWidth) {
  builder.addFieldInt32(5, poolWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} poolHeight
 */
armnnSerializer.Pooling2dDescriptor.addPoolHeight = function(builder, poolHeight) {
  builder.addFieldInt32(6, poolHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
armnnSerializer.Pooling2dDescriptor.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(7, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
armnnSerializer.Pooling2dDescriptor.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(8, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.OutputShapeRounding} outputShapeRounding
 */
armnnSerializer.Pooling2dDescriptor.addOutputShapeRounding = function(builder, outputShapeRounding) {
  builder.addFieldInt8(9, outputShapeRounding, armnnSerializer.OutputShapeRounding.Floor);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.PaddingMethod} paddingMethod
 */
armnnSerializer.Pooling2dDescriptor.addPaddingMethod = function(builder, paddingMethod) {
  builder.addFieldInt8(10, paddingMethod, armnnSerializer.PaddingMethod.IgnoreValue);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.Pooling2dDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(11, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Pooling2dDescriptor.endPooling2dDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.PoolingAlgorithm} poolType
 * @param {number} padLeft
 * @param {number} padRight
 * @param {number} padTop
 * @param {number} padBottom
 * @param {number} poolWidth
 * @param {number} poolHeight
 * @param {number} strideX
 * @param {number} strideY
 * @param {armnnSerializer.OutputShapeRounding} outputShapeRounding
 * @param {armnnSerializer.PaddingMethod} paddingMethod
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.Pooling2dDescriptor.createPooling2dDescriptor = function(builder, poolType, padLeft, padRight, padTop, padBottom, poolWidth, poolHeight, strideX, strideY, outputShapeRounding, paddingMethod, dataLayout) {
  armnnSerializer.Pooling2dDescriptor.startPooling2dDescriptor(builder);
  armnnSerializer.Pooling2dDescriptor.addPoolType(builder, poolType);
  armnnSerializer.Pooling2dDescriptor.addPadLeft(builder, padLeft);
  armnnSerializer.Pooling2dDescriptor.addPadRight(builder, padRight);
  armnnSerializer.Pooling2dDescriptor.addPadTop(builder, padTop);
  armnnSerializer.Pooling2dDescriptor.addPadBottom(builder, padBottom);
  armnnSerializer.Pooling2dDescriptor.addPoolWidth(builder, poolWidth);
  armnnSerializer.Pooling2dDescriptor.addPoolHeight(builder, poolHeight);
  armnnSerializer.Pooling2dDescriptor.addStrideX(builder, strideX);
  armnnSerializer.Pooling2dDescriptor.addStrideY(builder, strideY);
  armnnSerializer.Pooling2dDescriptor.addOutputShapeRounding(builder, outputShapeRounding);
  armnnSerializer.Pooling2dDescriptor.addPaddingMethod(builder, paddingMethod);
  armnnSerializer.Pooling2dDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.Pooling2dDescriptor.endPooling2dDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.QuantizeLayer.startQuantizeLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.QuantizeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizeLayer.endQuantizeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizeLayer.createQuantizeLayer = function(builder, baseOffset) {
  armnnSerializer.QuantizeLayer.startQuantizeLayer(builder);
  armnnSerializer.QuantizeLayer.addBase(builder, baseOffset);
  return armnnSerializer.QuantizeLayer.endQuantizeLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.SoftmaxDescriptor=} obj
 * @returns {armnnSerializer.SoftmaxDescriptor|null}
 */
armnnSerializer.SoftmaxLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.SoftmaxDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SoftmaxLayer.startSoftmaxLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SoftmaxLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.SoftmaxLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SoftmaxLayer.endSoftmaxLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SoftmaxLayer.createSoftmaxLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.SoftmaxLayer.startSoftmaxLayer(builder);
  armnnSerializer.SoftmaxLayer.addBase(builder, baseOffset);
  armnnSerializer.SoftmaxLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.SoftmaxLayer.endSoftmaxLayer(builder);
}

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

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SoftmaxDescriptor.endSoftmaxDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SoftmaxDescriptor.createSoftmaxDescriptor = function(builder, beta) {
  armnnSerializer.SoftmaxDescriptor.startSoftmaxDescriptor(builder);
  armnnSerializer.SoftmaxDescriptor.addBeta(builder, beta);
  return armnnSerializer.SoftmaxDescriptor.endSoftmaxDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.DepthwiseConvolution2dDescriptor=} obj
 * @returns {armnnSerializer.DepthwiseConvolution2dDescriptor|null}
 */
armnnSerializer.DepthwiseConvolution2dLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.DepthwiseConvolution2dDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.DepthwiseConvolution2dLayer.prototype.weights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DepthwiseConvolution2dLayer.startDepthwiseConvolution2dLayer = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.DepthwiseConvolution2dLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.DepthwiseConvolution2dLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightsOffset
 */
armnnSerializer.DepthwiseConvolution2dLayer.addWeights = function(builder, weightsOffset) {
  builder.addFieldOffset(2, weightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasesOffset
 */
armnnSerializer.DepthwiseConvolution2dLayer.addBiases = function(builder, biasesOffset) {
  builder.addFieldOffset(3, biasesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthwiseConvolution2dLayer.endDepthwiseConvolution2dLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} weightsOffset
 * @param {flatbuffers.Offset} biasesOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthwiseConvolution2dLayer.createDepthwiseConvolution2dLayer = function(builder, baseOffset, descriptorOffset, weightsOffset, biasesOffset) {
  armnnSerializer.DepthwiseConvolution2dLayer.startDepthwiseConvolution2dLayer(builder);
  armnnSerializer.DepthwiseConvolution2dLayer.addBase(builder, baseOffset);
  armnnSerializer.DepthwiseConvolution2dLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.DepthwiseConvolution2dLayer.addWeights(builder, weightsOffset);
  armnnSerializer.DepthwiseConvolution2dLayer.addBiases(builder, biasesOffset);
  return armnnSerializer.DepthwiseConvolution2dLayer.endDepthwiseConvolution2dLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.padRight = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.padBottom = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.dilationX = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.dilationY = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 1;
};

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.startDepthwiseConvolution2dDescriptor = function(builder) {
  builder.startObject(10);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addPadLeft = function(builder, padLeft) {
  builder.addFieldInt32(0, padLeft, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padRight
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addPadRight = function(builder, padRight) {
  builder.addFieldInt32(1, padRight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padTop
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addPadTop = function(builder, padTop) {
  builder.addFieldInt32(2, padTop, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padBottom
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addPadBottom = function(builder, padBottom) {
  builder.addFieldInt32(3, padBottom, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(4, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(5, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationX
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addDilationX = function(builder, dilationX) {
  builder.addFieldInt32(6, dilationX, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilationY
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addDilationY = function(builder, dilationY) {
  builder.addFieldInt32(7, dilationY, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasEnabled
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addBiasEnabled = function(builder, biasEnabled) {
  builder.addFieldInt8(8, +biasEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(9, dataLayout, armnnSerializer.DataLayout.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.endDepthwiseConvolution2dDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 * @param {number} padRight
 * @param {number} padTop
 * @param {number} padBottom
 * @param {number} strideX
 * @param {number} strideY
 * @param {number} dilationX
 * @param {number} dilationY
 * @param {boolean} biasEnabled
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DepthwiseConvolution2dDescriptor.createDepthwiseConvolution2dDescriptor = function(builder, padLeft, padRight, padTop, padBottom, strideX, strideY, dilationX, dilationY, biasEnabled, dataLayout) {
  armnnSerializer.DepthwiseConvolution2dDescriptor.startDepthwiseConvolution2dDescriptor(builder);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addPadLeft(builder, padLeft);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addPadRight(builder, padRight);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addPadTop(builder, padTop);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addPadBottom(builder, padBottom);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addStrideX(builder, strideX);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addStrideY(builder, strideY);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addDilationX(builder, dilationX);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addDilationY(builder, dilationY);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addBiasEnabled(builder, biasEnabled);
  armnnSerializer.DepthwiseConvolution2dDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.DepthwiseConvolution2dDescriptor.endDepthwiseConvolution2dDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.OutputLayer.startOutputLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.OutputLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OutputLayer.endOutputLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OutputLayer.createOutputLayer = function(builder, baseOffset) {
  armnnSerializer.OutputLayer.startOutputLayer(builder);
  armnnSerializer.OutputLayer.addBase(builder, baseOffset);
  return armnnSerializer.OutputLayer.endOutputLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ReshapeDescriptor=} obj
 * @returns {armnnSerializer.ReshapeDescriptor|null}
 */
armnnSerializer.ReshapeLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ReshapeDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ReshapeLayer.startReshapeLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ReshapeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ReshapeLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ReshapeLayer.endReshapeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ReshapeLayer.createReshapeLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ReshapeLayer.startReshapeLayer(builder);
  armnnSerializer.ReshapeLayer.addBase(builder, baseOffset);
  armnnSerializer.ReshapeLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ReshapeLayer.endReshapeLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.ReshapeDescriptor.prototype.targetShape = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ReshapeDescriptor.startReshapeDescriptor = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} targetShapeOffset
 */
armnnSerializer.ReshapeDescriptor.addTargetShape = function(builder, targetShapeOffset) {
  builder.addFieldOffset(0, targetShapeOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ReshapeDescriptor.endReshapeDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} targetShapeOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ReshapeDescriptor.createReshapeDescriptor = function(builder, targetShapeOffset) {
  armnnSerializer.ReshapeDescriptor.startReshapeDescriptor(builder);
  armnnSerializer.ReshapeDescriptor.addTargetShape(builder, targetShapeOffset);
  return armnnSerializer.ReshapeDescriptor.endReshapeDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.PermuteDescriptor=} obj
 * @returns {armnnSerializer.PermuteDescriptor|null}
 */
armnnSerializer.PermuteLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.PermuteDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.PermuteLayer.startPermuteLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.PermuteLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.PermuteLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PermuteLayer.endPermuteLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PermuteLayer.createPermuteLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.PermuteLayer.startPermuteLayer(builder);
  armnnSerializer.PermuteLayer.addBase(builder, baseOffset);
  armnnSerializer.PermuteLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.PermuteLayer.endPermuteLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.PermuteDescriptor.prototype.dimMappings = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.PermuteDescriptor.startPermuteDescriptor = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimMappingsOffset
 */
armnnSerializer.PermuteDescriptor.addDimMappings = function(builder, dimMappingsOffset) {
  builder.addFieldOffset(0, dimMappingsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PermuteDescriptor.endPermuteDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimMappingsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PermuteDescriptor.createPermuteDescriptor = function(builder, dimMappingsOffset) {
  armnnSerializer.PermuteDescriptor.startPermuteDescriptor(builder);
  armnnSerializer.PermuteDescriptor.addDimMappings(builder, dimMappingsOffset);
  return armnnSerializer.PermuteDescriptor.endPermuteDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.SpaceToBatchNdDescriptor=} obj
 * @returns {armnnSerializer.SpaceToBatchNdDescriptor|null}
 */
armnnSerializer.SpaceToBatchNdLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.SpaceToBatchNdDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SpaceToBatchNdLayer.startSpaceToBatchNdLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SpaceToBatchNdLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.SpaceToBatchNdLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToBatchNdLayer.endSpaceToBatchNdLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToBatchNdLayer.createSpaceToBatchNdLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.SpaceToBatchNdLayer.startSpaceToBatchNdLayer(builder);
  armnnSerializer.SpaceToBatchNdLayer.addBase(builder, baseOffset);
  armnnSerializer.SpaceToBatchNdLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.SpaceToBatchNdLayer.endSpaceToBatchNdLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.SpaceToBatchNdDescriptor.prototype.blockShape = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.SpaceToBatchNdDescriptor.prototype.padList = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.SpaceToBatchNdDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SpaceToBatchNdDescriptor.startSpaceToBatchNdDescriptor = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 */
armnnSerializer.SpaceToBatchNdDescriptor.addBlockShape = function(builder, blockShapeOffset) {
  builder.addFieldOffset(0, blockShapeOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padListOffset
 */
armnnSerializer.SpaceToBatchNdDescriptor.addPadList = function(builder, padListOffset) {
  builder.addFieldOffset(1, padListOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.SpaceToBatchNdDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(2, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToBatchNdDescriptor.endSpaceToBatchNdDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 * @param {flatbuffers.Offset} padListOffset
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToBatchNdDescriptor.createSpaceToBatchNdDescriptor = function(builder, blockShapeOffset, padListOffset, dataLayout) {
  armnnSerializer.SpaceToBatchNdDescriptor.startSpaceToBatchNdDescriptor(builder);
  armnnSerializer.SpaceToBatchNdDescriptor.addBlockShape(builder, blockShapeOffset);
  armnnSerializer.SpaceToBatchNdDescriptor.addPadList(builder, padListOffset);
  armnnSerializer.SpaceToBatchNdDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.SpaceToBatchNdDescriptor.endSpaceToBatchNdDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.SpaceToDepthDescriptor=} obj
 * @returns {armnnSerializer.SpaceToDepthDescriptor|null}
 */
armnnSerializer.SpaceToDepthLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.SpaceToDepthDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SpaceToDepthLayer.startSpaceToDepthLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SpaceToDepthLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.SpaceToDepthLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToDepthLayer.endSpaceToDepthLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToDepthLayer.createSpaceToDepthLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.SpaceToDepthLayer.startSpaceToDepthLayer(builder);
  armnnSerializer.SpaceToDepthLayer.addBase(builder, baseOffset);
  armnnSerializer.SpaceToDepthLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.SpaceToDepthLayer.endSpaceToDepthLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.SpaceToDepthDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SpaceToDepthDescriptor.startSpaceToDepthDescriptor = function(builder) {
  builder.startObject(2);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.SpaceToDepthDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(1, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToDepthDescriptor.endSpaceToDepthDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SpaceToDepthDescriptor.createSpaceToDepthDescriptor = function(builder, blockSize, dataLayout) {
  armnnSerializer.SpaceToDepthDescriptor.startSpaceToDepthDescriptor(builder);
  armnnSerializer.SpaceToDepthDescriptor.addBlockSize(builder, blockSize);
  armnnSerializer.SpaceToDepthDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.SpaceToDepthDescriptor.endSpaceToDepthDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SubtractionLayer.startSubtractionLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SubtractionLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SubtractionLayer.endSubtractionLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SubtractionLayer.createSubtractionLayer = function(builder, baseOffset) {
  armnnSerializer.SubtractionLayer.startSubtractionLayer(builder);
  armnnSerializer.SubtractionLayer.addBase(builder, baseOffset);
  return armnnSerializer.SubtractionLayer.endSubtractionLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.BatchToSpaceNdDescriptor=} obj
 * @returns {armnnSerializer.BatchToSpaceNdDescriptor|null}
 */
armnnSerializer.BatchToSpaceNdLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.BatchToSpaceNdDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.BatchToSpaceNdLayer.startBatchToSpaceNdLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.BatchToSpaceNdLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.BatchToSpaceNdLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchToSpaceNdLayer.endBatchToSpaceNdLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchToSpaceNdLayer.createBatchToSpaceNdLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.BatchToSpaceNdLayer.startBatchToSpaceNdLayer(builder);
  armnnSerializer.BatchToSpaceNdLayer.addBase(builder, baseOffset);
  armnnSerializer.BatchToSpaceNdLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.BatchToSpaceNdLayer.endBatchToSpaceNdLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.BatchToSpaceNdDescriptor.prototype.blockShape = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.BatchToSpaceNdDescriptor.prototype.crops = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.BatchToSpaceNdDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.BatchToSpaceNdDescriptor.startBatchToSpaceNdDescriptor = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 */
armnnSerializer.BatchToSpaceNdDescriptor.addBlockShape = function(builder, blockShapeOffset) {
  builder.addFieldOffset(0, blockShapeOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cropsOffset
 */
armnnSerializer.BatchToSpaceNdDescriptor.addCrops = function(builder, cropsOffset) {
  builder.addFieldOffset(1, cropsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.BatchToSpaceNdDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(2, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchToSpaceNdDescriptor.endBatchToSpaceNdDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 * @param {flatbuffers.Offset} cropsOffset
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchToSpaceNdDescriptor.createBatchToSpaceNdDescriptor = function(builder, blockShapeOffset, cropsOffset, dataLayout) {
  armnnSerializer.BatchToSpaceNdDescriptor.startBatchToSpaceNdDescriptor(builder);
  armnnSerializer.BatchToSpaceNdDescriptor.addBlockShape(builder, blockShapeOffset);
  armnnSerializer.BatchToSpaceNdDescriptor.addCrops(builder, cropsOffset);
  armnnSerializer.BatchToSpaceNdDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.BatchToSpaceNdDescriptor.endBatchToSpaceNdDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.NormalizationDescriptor=} obj
 * @returns {armnnSerializer.NormalizationDescriptor|null}
 */
armnnSerializer.NormalizationLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.NormalizationDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.NormalizationLayer.startNormalizationLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.NormalizationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.NormalizationLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.NormalizationLayer.endNormalizationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.NormalizationLayer.createNormalizationLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.NormalizationLayer.startNormalizationLayer(builder);
  armnnSerializer.NormalizationLayer.addBase(builder, baseOffset);
  armnnSerializer.NormalizationLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.NormalizationLayer.endNormalizationLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.NormalizationAlgorithmChannel}
 */
armnnSerializer.NormalizationDescriptor.prototype.normChannelType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.NormalizationAlgorithmChannel} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.NormalizationAlgorithmChannel.Across;
};

/**
 * @returns {armnnSerializer.NormalizationAlgorithmMethod}
 */
armnnSerializer.NormalizationDescriptor.prototype.normMethodType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.NormalizationAlgorithmMethod} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.NormalizationAlgorithmMethod.LocalBrightness;
};

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.NormalizationDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.NormalizationDescriptor.startNormalizationDescriptor = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.NormalizationAlgorithmChannel} normChannelType
 */
armnnSerializer.NormalizationDescriptor.addNormChannelType = function(builder, normChannelType) {
  builder.addFieldInt8(0, normChannelType, armnnSerializer.NormalizationAlgorithmChannel.Across);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.NormalizationAlgorithmMethod} normMethodType
 */
armnnSerializer.NormalizationDescriptor.addNormMethodType = function(builder, normMethodType) {
  builder.addFieldInt8(1, normMethodType, armnnSerializer.NormalizationAlgorithmMethod.LocalBrightness);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} normSize
 */
armnnSerializer.NormalizationDescriptor.addNormSize = function(builder, normSize) {
  builder.addFieldInt32(2, normSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 */
armnnSerializer.NormalizationDescriptor.addAlpha = function(builder, alpha) {
  builder.addFieldFloat32(3, alpha, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
armnnSerializer.NormalizationDescriptor.addBeta = function(builder, beta) {
  builder.addFieldFloat32(4, beta, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} k
 */
armnnSerializer.NormalizationDescriptor.addK = function(builder, k) {
  builder.addFieldFloat32(5, k, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.NormalizationDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(6, dataLayout, armnnSerializer.DataLayout.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.NormalizationDescriptor.endNormalizationDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.NormalizationAlgorithmChannel} normChannelType
 * @param {armnnSerializer.NormalizationAlgorithmMethod} normMethodType
 * @param {number} normSize
 * @param {number} alpha
 * @param {number} beta
 * @param {number} k
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.NormalizationDescriptor.createNormalizationDescriptor = function(builder, normChannelType, normMethodType, normSize, alpha, beta, k, dataLayout) {
  armnnSerializer.NormalizationDescriptor.startNormalizationDescriptor(builder);
  armnnSerializer.NormalizationDescriptor.addNormChannelType(builder, normChannelType);
  armnnSerializer.NormalizationDescriptor.addNormMethodType(builder, normMethodType);
  armnnSerializer.NormalizationDescriptor.addNormSize(builder, normSize);
  armnnSerializer.NormalizationDescriptor.addAlpha(builder, alpha);
  armnnSerializer.NormalizationDescriptor.addBeta(builder, beta);
  armnnSerializer.NormalizationDescriptor.addK(builder, k);
  armnnSerializer.NormalizationDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.NormalizationDescriptor.endNormalizationDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.MeanDescriptor=} obj
 * @returns {armnnSerializer.MeanDescriptor|null}
 */
armnnSerializer.MeanLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.MeanDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MeanLayer.startMeanLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MeanLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.MeanLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MeanLayer.endMeanLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MeanLayer.createMeanLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.MeanLayer.startMeanLayer(builder);
  armnnSerializer.MeanLayer.addBase(builder, baseOffset);
  armnnSerializer.MeanLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.MeanLayer.endMeanLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.MeanDescriptor.prototype.axis = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MeanDescriptor.startMeanDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} axisOffset
 */
armnnSerializer.MeanDescriptor.addAxis = function(builder, axisOffset) {
  builder.addFieldOffset(0, axisOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 */
armnnSerializer.MeanDescriptor.addKeepDims = function(builder, keepDims) {
  builder.addFieldInt8(1, +keepDims, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MeanDescriptor.endMeanDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} axisOffset
 * @param {boolean} keepDims
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MeanDescriptor.createMeanDescriptor = function(builder, axisOffset, keepDims) {
  armnnSerializer.MeanDescriptor.startMeanDescriptor(builder);
  armnnSerializer.MeanDescriptor.addAxis(builder, axisOffset);
  armnnSerializer.MeanDescriptor.addKeepDims(builder, keepDims);
  return armnnSerializer.MeanDescriptor.endMeanDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.PadDescriptor=} obj
 * @returns {armnnSerializer.PadDescriptor|null}
 */
armnnSerializer.PadLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.PadDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.PadLayer.startPadLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.PadLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.PadLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PadLayer.endPadLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PadLayer.createPadLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.PadLayer.startPadLayer(builder);
  armnnSerializer.PadLayer.addBase(builder, baseOffset);
  armnnSerializer.PadLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.PadLayer.endPadLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.PadDescriptor.prototype.padList = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.PadDescriptor.startPadDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padListOffset
 */
armnnSerializer.PadDescriptor.addPadList = function(builder, padListOffset) {
  builder.addFieldOffset(0, padListOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padValue
 */
armnnSerializer.PadDescriptor.addPadValue = function(builder, padValue) {
  builder.addFieldFloat32(1, padValue, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PadDescriptor.endPadDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padListOffset
 * @param {number} padValue
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PadDescriptor.createPadDescriptor = function(builder, padListOffset, padValue) {
  armnnSerializer.PadDescriptor.startPadDescriptor(builder);
  armnnSerializer.PadDescriptor.addPadList(builder, padListOffset);
  armnnSerializer.PadDescriptor.addPadValue(builder, padValue);
  return armnnSerializer.PadDescriptor.endPadDescriptor(builder);
}

/**
 * @deprecated Use ElementwiseUnaryLayer instead
 *
 * @constructor
 */
armnnSerializer.RsqrtLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.RsqrtLayer.startRsqrtLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.RsqrtLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.RsqrtLayer.endRsqrtLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.RsqrtLayer.createRsqrtLayer = function(builder, baseOffset) {
  armnnSerializer.RsqrtLayer.startRsqrtLayer(builder);
  armnnSerializer.RsqrtLayer.addBase(builder, baseOffset);
  return armnnSerializer.RsqrtLayer.endRsqrtLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.BatchNormalizationDescriptor=} obj
 * @returns {armnnSerializer.BatchNormalizationDescriptor|null}
 */
armnnSerializer.BatchNormalizationLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.BatchNormalizationDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.BatchNormalizationLayer.prototype.mean = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.BatchNormalizationLayer.startBatchNormalizationLayer = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.BatchNormalizationLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.BatchNormalizationLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} meanOffset
 */
armnnSerializer.BatchNormalizationLayer.addMean = function(builder, meanOffset) {
  builder.addFieldOffset(2, meanOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} varianceOffset
 */
armnnSerializer.BatchNormalizationLayer.addVariance = function(builder, varianceOffset) {
  builder.addFieldOffset(3, varianceOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} betaOffset
 */
armnnSerializer.BatchNormalizationLayer.addBeta = function(builder, betaOffset) {
  builder.addFieldOffset(4, betaOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} gammaOffset
 */
armnnSerializer.BatchNormalizationLayer.addGamma = function(builder, gammaOffset) {
  builder.addFieldOffset(5, gammaOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchNormalizationLayer.endBatchNormalizationLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} meanOffset
 * @param {flatbuffers.Offset} varianceOffset
 * @param {flatbuffers.Offset} betaOffset
 * @param {flatbuffers.Offset} gammaOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchNormalizationLayer.createBatchNormalizationLayer = function(builder, baseOffset, descriptorOffset, meanOffset, varianceOffset, betaOffset, gammaOffset) {
  armnnSerializer.BatchNormalizationLayer.startBatchNormalizationLayer(builder);
  armnnSerializer.BatchNormalizationLayer.addBase(builder, baseOffset);
  armnnSerializer.BatchNormalizationLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.BatchNormalizationLayer.addMean(builder, meanOffset);
  armnnSerializer.BatchNormalizationLayer.addVariance(builder, varianceOffset);
  armnnSerializer.BatchNormalizationLayer.addBeta(builder, betaOffset);
  armnnSerializer.BatchNormalizationLayer.addGamma(builder, gammaOffset);
  return armnnSerializer.BatchNormalizationLayer.endBatchNormalizationLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.BatchNormalizationDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.BatchNormalizationDescriptor.startBatchNormalizationDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} eps
 */
armnnSerializer.BatchNormalizationDescriptor.addEps = function(builder, eps) {
  builder.addFieldFloat32(0, eps, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.BatchNormalizationDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(1, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchNormalizationDescriptor.endBatchNormalizationDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} eps
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.BatchNormalizationDescriptor.createBatchNormalizationDescriptor = function(builder, eps, dataLayout) {
  armnnSerializer.BatchNormalizationDescriptor.startBatchNormalizationDescriptor(builder);
  armnnSerializer.BatchNormalizationDescriptor.addEps(builder, eps);
  armnnSerializer.BatchNormalizationDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.BatchNormalizationDescriptor.endBatchNormalizationDescriptor(builder);
}

/**
 * @deprecated Use ResizeLayer instead
 *
 * @constructor
 */
armnnSerializer.ResizeBilinearLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {armnnSerializer.ResizeBilinearDescriptor=} obj
 * @returns {armnnSerializer.ResizeBilinearDescriptor|null}
 */
armnnSerializer.ResizeBilinearLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ResizeBilinearDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ResizeBilinearLayer.startResizeBilinearLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ResizeBilinearLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ResizeBilinearLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeBilinearLayer.endResizeBilinearLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeBilinearLayer.createResizeBilinearLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ResizeBilinearLayer.startResizeBilinearLayer(builder);
  armnnSerializer.ResizeBilinearLayer.addBase(builder, baseOffset);
  armnnSerializer.ResizeBilinearLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ResizeBilinearLayer.endResizeBilinearLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.ResizeBilinearDescriptor.prototype.targetHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.ResizeBilinearDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ResizeBilinearDescriptor.startResizeBilinearDescriptor = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetWidth
 */
armnnSerializer.ResizeBilinearDescriptor.addTargetWidth = function(builder, targetWidth) {
  builder.addFieldInt32(0, targetWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetHeight
 */
armnnSerializer.ResizeBilinearDescriptor.addTargetHeight = function(builder, targetHeight) {
  builder.addFieldInt32(1, targetHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.ResizeBilinearDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(2, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeBilinearDescriptor.endResizeBilinearDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetWidth
 * @param {number} targetHeight
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeBilinearDescriptor.createResizeBilinearDescriptor = function(builder, targetWidth, targetHeight, dataLayout) {
  armnnSerializer.ResizeBilinearDescriptor.startResizeBilinearDescriptor(builder);
  armnnSerializer.ResizeBilinearDescriptor.addTargetWidth(builder, targetWidth);
  armnnSerializer.ResizeBilinearDescriptor.addTargetHeight(builder, targetHeight);
  armnnSerializer.ResizeBilinearDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.ResizeBilinearDescriptor.endResizeBilinearDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.SliceDescriptor=} obj
 * @returns {armnnSerializer.SliceDescriptor|null}
 */
armnnSerializer.SliceLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.SliceDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SliceLayer.startSliceLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SliceLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.SliceLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SliceLayer.endSliceLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SliceLayer.createSliceLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.SliceLayer.startSliceLayer(builder);
  armnnSerializer.SliceLayer.addBase(builder, baseOffset);
  armnnSerializer.SliceLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.SliceLayer.endSliceLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.SliceDescriptor.prototype.begin = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.SliceDescriptor.prototype.size = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SliceDescriptor.startSliceDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} beginOffset
 */
armnnSerializer.SliceDescriptor.addBegin = function(builder, beginOffset) {
  builder.addFieldOffset(0, beginOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sizeOffset
 */
armnnSerializer.SliceDescriptor.addSize = function(builder, sizeOffset) {
  builder.addFieldOffset(1, sizeOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SliceDescriptor.endSliceDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} beginOffset
 * @param {flatbuffers.Offset} sizeOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SliceDescriptor.createSliceDescriptor = function(builder, beginOffset, sizeOffset) {
  armnnSerializer.SliceDescriptor.startSliceDescriptor(builder);
  armnnSerializer.SliceDescriptor.addBegin(builder, beginOffset);
  armnnSerializer.SliceDescriptor.addSize(builder, sizeOffset);
  return armnnSerializer.SliceDescriptor.endSliceDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.StridedSliceDescriptor=} obj
 * @returns {armnnSerializer.StridedSliceDescriptor|null}
 */
armnnSerializer.StridedSliceLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.StridedSliceDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StridedSliceLayer.startStridedSliceLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.StridedSliceLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.StridedSliceLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StridedSliceLayer.endStridedSliceLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StridedSliceLayer.createStridedSliceLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.StridedSliceLayer.startStridedSliceLayer(builder);
  armnnSerializer.StridedSliceLayer.addBase(builder, baseOffset);
  armnnSerializer.StridedSliceLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.StridedSliceLayer.endStridedSliceLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {Int32Array}
 */
armnnSerializer.StridedSliceDescriptor.prototype.beginArray = 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}
 */
armnnSerializer.StridedSliceDescriptor.prototype.end = 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}
 */
armnnSerializer.StridedSliceDescriptor.prototype.endLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
armnnSerializer.StridedSliceDescriptor.prototype.endArray = 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}
 */
armnnSerializer.StridedSliceDescriptor.prototype.stride = 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}
 */
armnnSerializer.StridedSliceDescriptor.prototype.strideLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
armnnSerializer.StridedSliceDescriptor.prototype.strideArray = 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 {number}
 */
armnnSerializer.StridedSliceDescriptor.prototype.beginMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

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

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

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

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.StridedSliceDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StridedSliceDescriptor.startStridedSliceDescriptor = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} beginOffset
 */
armnnSerializer.StridedSliceDescriptor.addBegin = function(builder, beginOffset) {
  builder.addFieldOffset(0, beginOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} endOffset
 */
armnnSerializer.StridedSliceDescriptor.addEnd = function(builder, endOffset) {
  builder.addFieldOffset(1, endOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} strideOffset
 */
armnnSerializer.StridedSliceDescriptor.addStride = function(builder, strideOffset) {
  builder.addFieldOffset(2, strideOffset, 0);
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} endMask
 */
armnnSerializer.StridedSliceDescriptor.addEndMask = function(builder, endMask) {
  builder.addFieldInt32(4, endMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} shrinkAxisMask
 */
armnnSerializer.StridedSliceDescriptor.addShrinkAxisMask = function(builder, shrinkAxisMask) {
  builder.addFieldInt32(5, shrinkAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} ellipsisMask
 */
armnnSerializer.StridedSliceDescriptor.addEllipsisMask = function(builder, ellipsisMask) {
  builder.addFieldInt32(6, ellipsisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} newAxisMask
 */
armnnSerializer.StridedSliceDescriptor.addNewAxisMask = function(builder, newAxisMask) {
  builder.addFieldInt32(7, newAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.StridedSliceDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(8, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StridedSliceDescriptor.endStridedSliceDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} beginOffset
 * @param {flatbuffers.Offset} endOffset
 * @param {flatbuffers.Offset} strideOffset
 * @param {number} beginMask
 * @param {number} endMask
 * @param {number} shrinkAxisMask
 * @param {number} ellipsisMask
 * @param {number} newAxisMask
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StridedSliceDescriptor.createStridedSliceDescriptor = function(builder, beginOffset, endOffset, strideOffset, beginMask, endMask, shrinkAxisMask, ellipsisMask, newAxisMask, dataLayout) {
  armnnSerializer.StridedSliceDescriptor.startStridedSliceDescriptor(builder);
  armnnSerializer.StridedSliceDescriptor.addBegin(builder, beginOffset);
  armnnSerializer.StridedSliceDescriptor.addEnd(builder, endOffset);
  armnnSerializer.StridedSliceDescriptor.addStride(builder, strideOffset);
  armnnSerializer.StridedSliceDescriptor.addBeginMask(builder, beginMask);
  armnnSerializer.StridedSliceDescriptor.addEndMask(builder, endMask);
  armnnSerializer.StridedSliceDescriptor.addShrinkAxisMask(builder, shrinkAxisMask);
  armnnSerializer.StridedSliceDescriptor.addEllipsisMask(builder, ellipsisMask);
  armnnSerializer.StridedSliceDescriptor.addNewAxisMask(builder, newAxisMask);
  armnnSerializer.StridedSliceDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.StridedSliceDescriptor.endStridedSliceDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.OriginsDescriptor=} obj
 * @returns {armnnSerializer.OriginsDescriptor|null}
 */
armnnSerializer.ConcatLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.OriginsDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ConcatLayer.startConcatLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ConcatLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ConcatLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConcatLayer.endConcatLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ConcatLayer.createConcatLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ConcatLayer.startConcatLayer(builder);
  armnnSerializer.ConcatLayer.addBase(builder, baseOffset);
  armnnSerializer.ConcatLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ConcatLayer.endConcatLayer(builder);
}

/**
 * @deprecated Use ConcatLayer instead
 *
 * @constructor
 */
armnnSerializer.MergerLayer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

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

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

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

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

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

/**
 * @param {armnnSerializer.OriginsDescriptor=} obj
 * @returns {armnnSerializer.OriginsDescriptor|null}
 */
armnnSerializer.MergerLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.OriginsDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MergerLayer.startMergerLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MergerLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.MergerLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MergerLayer.endMergerLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MergerLayer.createMergerLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.MergerLayer.startMergerLayer(builder);
  armnnSerializer.MergerLayer.addBase(builder, baseOffset);
  armnnSerializer.MergerLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.MergerLayer.endMergerLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.UintVector.prototype.data = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.UintVector.startUintVector = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 */
armnnSerializer.UintVector.addData = function(builder, dataOffset) {
  builder.addFieldOffset(0, dataOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.UintVector.endUintVector = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dataOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.UintVector.createUintVector = function(builder, dataOffset) {
  armnnSerializer.UintVector.startUintVector(builder);
  armnnSerializer.UintVector.addData(builder, dataOffset);
  return armnnSerializer.UintVector.endUintVector(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.OriginsDescriptor.prototype.numViews = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @param {number} index
 * @param {armnnSerializer.UintVector=} obj
 * @returns {armnnSerializer.UintVector}
 */
armnnSerializer.OriginsDescriptor.prototype.viewOrigins = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new armnnSerializer.UintVector).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.OriginsDescriptor.startOriginsDescriptor = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} concatAxis
 */
armnnSerializer.OriginsDescriptor.addConcatAxis = function(builder, concatAxis) {
  builder.addFieldInt32(0, concatAxis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numViews
 */
armnnSerializer.OriginsDescriptor.addNumViews = function(builder, numViews) {
  builder.addFieldInt32(1, numViews, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numDimensions
 */
armnnSerializer.OriginsDescriptor.addNumDimensions = function(builder, numDimensions) {
  builder.addFieldInt32(2, numDimensions, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} viewOriginsOffset
 */
armnnSerializer.OriginsDescriptor.addViewOrigins = function(builder, viewOriginsOffset) {
  builder.addFieldOffset(3, viewOriginsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OriginsDescriptor.createViewOriginsVector = 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
 */
armnnSerializer.OriginsDescriptor.startViewOriginsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OriginsDescriptor.endOriginsDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} concatAxis
 * @param {number} numViews
 * @param {number} numDimensions
 * @param {flatbuffers.Offset} viewOriginsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.OriginsDescriptor.createOriginsDescriptor = function(builder, concatAxis, numViews, numDimensions, viewOriginsOffset) {
  armnnSerializer.OriginsDescriptor.startOriginsDescriptor(builder);
  armnnSerializer.OriginsDescriptor.addConcatAxis(builder, concatAxis);
  armnnSerializer.OriginsDescriptor.addNumViews(builder, numViews);
  armnnSerializer.OriginsDescriptor.addNumDimensions(builder, numDimensions);
  armnnSerializer.OriginsDescriptor.addViewOrigins(builder, viewOriginsOffset);
  return armnnSerializer.OriginsDescriptor.endOriginsDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {number} index
 * @param {armnnSerializer.UintVector=} obj
 * @returns {armnnSerializer.UintVector}
 */
armnnSerializer.ViewsDescriptor.prototype.viewSizes = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.UintVector).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ViewsDescriptor.startViewsDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} originsOffset
 */
armnnSerializer.ViewsDescriptor.addOrigins = function(builder, originsOffset) {
  builder.addFieldOffset(0, originsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} viewSizesOffset
 */
armnnSerializer.ViewsDescriptor.addViewSizes = function(builder, viewSizesOffset) {
  builder.addFieldOffset(1, viewSizesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ViewsDescriptor.createViewSizesVector = 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
 */
armnnSerializer.ViewsDescriptor.startViewSizesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ViewsDescriptor.endViewsDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} originsOffset
 * @param {flatbuffers.Offset} viewSizesOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ViewsDescriptor.createViewsDescriptor = function(builder, originsOffset, viewSizesOffset) {
  armnnSerializer.ViewsDescriptor.startViewsDescriptor(builder);
  armnnSerializer.ViewsDescriptor.addOrigins(builder, originsOffset);
  armnnSerializer.ViewsDescriptor.addViewSizes(builder, viewSizesOffset);
  return armnnSerializer.ViewsDescriptor.endViewsDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ViewsDescriptor=} obj
 * @returns {armnnSerializer.ViewsDescriptor|null}
 */
armnnSerializer.SplitterLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ViewsDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SplitterLayer.startSplitterLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SplitterLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.SplitterLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SplitterLayer.endSplitterLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SplitterLayer.createSplitterLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.SplitterLayer.startSplitterLayer(builder);
  armnnSerializer.SplitterLayer.addBase(builder, baseOffset);
  armnnSerializer.SplitterLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.SplitterLayer.endSplitterLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.DetectionPostProcessDescriptor=} obj
 * @returns {armnnSerializer.DetectionPostProcessDescriptor|null}
 */
armnnSerializer.DetectionPostProcessLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.DetectionPostProcessDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DetectionPostProcessLayer.startDetectionPostProcessLayer = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.DetectionPostProcessLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.DetectionPostProcessLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} anchorsOffset
 */
armnnSerializer.DetectionPostProcessLayer.addAnchors = function(builder, anchorsOffset) {
  builder.addFieldOffset(2, anchorsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DetectionPostProcessLayer.endDetectionPostProcessLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} anchorsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DetectionPostProcessLayer.createDetectionPostProcessLayer = function(builder, baseOffset, descriptorOffset, anchorsOffset) {
  armnnSerializer.DetectionPostProcessLayer.startDetectionPostProcessLayer(builder);
  armnnSerializer.DetectionPostProcessLayer.addBase(builder, baseOffset);
  armnnSerializer.DetectionPostProcessLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.DetectionPostProcessLayer.addAnchors(builder, anchorsOffset);
  return armnnSerializer.DetectionPostProcessLayer.endDetectionPostProcessLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.DetectionPostProcessDescriptor.prototype.maxClassesPerDetection = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.DetectionPostProcessDescriptor.prototype.numClasses = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.DetectionPostProcessDescriptor.prototype.scaleX = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.DetectionPostProcessDescriptor.prototype.scaleW = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
armnnSerializer.DetectionPostProcessDescriptor.prototype.scaleH = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DetectionPostProcessDescriptor.startDetectionPostProcessDescriptor = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxDetections
 */
armnnSerializer.DetectionPostProcessDescriptor.addMaxDetections = function(builder, maxDetections) {
  builder.addFieldInt32(0, maxDetections, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxClassesPerDetection
 */
armnnSerializer.DetectionPostProcessDescriptor.addMaxClassesPerDetection = function(builder, maxClassesPerDetection) {
  builder.addFieldInt32(1, maxClassesPerDetection, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} detectionsPerClass
 */
armnnSerializer.DetectionPostProcessDescriptor.addDetectionsPerClass = function(builder, detectionsPerClass) {
  builder.addFieldInt32(2, detectionsPerClass, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsScoreThreshold
 */
armnnSerializer.DetectionPostProcessDescriptor.addNmsScoreThreshold = function(builder, nmsScoreThreshold) {
  builder.addFieldFloat32(3, nmsScoreThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsIouThreshold
 */
armnnSerializer.DetectionPostProcessDescriptor.addNmsIouThreshold = function(builder, nmsIouThreshold) {
  builder.addFieldFloat32(4, nmsIouThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numClasses
 */
armnnSerializer.DetectionPostProcessDescriptor.addNumClasses = function(builder, numClasses) {
  builder.addFieldInt32(5, numClasses, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} useRegularNms
 */
armnnSerializer.DetectionPostProcessDescriptor.addUseRegularNms = function(builder, useRegularNms) {
  builder.addFieldInt8(6, +useRegularNms, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleX
 */
armnnSerializer.DetectionPostProcessDescriptor.addScaleX = function(builder, scaleX) {
  builder.addFieldFloat32(7, scaleX, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleY
 */
armnnSerializer.DetectionPostProcessDescriptor.addScaleY = function(builder, scaleY) {
  builder.addFieldFloat32(8, scaleY, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleW
 */
armnnSerializer.DetectionPostProcessDescriptor.addScaleW = function(builder, scaleW) {
  builder.addFieldFloat32(9, scaleW, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleH
 */
armnnSerializer.DetectionPostProcessDescriptor.addScaleH = function(builder, scaleH) {
  builder.addFieldFloat32(10, scaleH, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DetectionPostProcessDescriptor.endDetectionPostProcessDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxDetections
 * @param {number} maxClassesPerDetection
 * @param {number} detectionsPerClass
 * @param {number} nmsScoreThreshold
 * @param {number} nmsIouThreshold
 * @param {number} numClasses
 * @param {boolean} useRegularNms
 * @param {number} scaleX
 * @param {number} scaleY
 * @param {number} scaleW
 * @param {number} scaleH
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DetectionPostProcessDescriptor.createDetectionPostProcessDescriptor = function(builder, maxDetections, maxClassesPerDetection, detectionsPerClass, nmsScoreThreshold, nmsIouThreshold, numClasses, useRegularNms, scaleX, scaleY, scaleW, scaleH) {
  armnnSerializer.DetectionPostProcessDescriptor.startDetectionPostProcessDescriptor(builder);
  armnnSerializer.DetectionPostProcessDescriptor.addMaxDetections(builder, maxDetections);
  armnnSerializer.DetectionPostProcessDescriptor.addMaxClassesPerDetection(builder, maxClassesPerDetection);
  armnnSerializer.DetectionPostProcessDescriptor.addDetectionsPerClass(builder, detectionsPerClass);
  armnnSerializer.DetectionPostProcessDescriptor.addNmsScoreThreshold(builder, nmsScoreThreshold);
  armnnSerializer.DetectionPostProcessDescriptor.addNmsIouThreshold(builder, nmsIouThreshold);
  armnnSerializer.DetectionPostProcessDescriptor.addNumClasses(builder, numClasses);
  armnnSerializer.DetectionPostProcessDescriptor.addUseRegularNms(builder, useRegularNms);
  armnnSerializer.DetectionPostProcessDescriptor.addScaleX(builder, scaleX);
  armnnSerializer.DetectionPostProcessDescriptor.addScaleY(builder, scaleY);
  armnnSerializer.DetectionPostProcessDescriptor.addScaleW(builder, scaleW);
  armnnSerializer.DetectionPostProcessDescriptor.addScaleH(builder, scaleH);
  return armnnSerializer.DetectionPostProcessDescriptor.endDetectionPostProcessDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.inputToCellWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.inputToOutputWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.inputToInputWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.recurrentToInputWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.cellToInputWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.inputGateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 28);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.projectionWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 30);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.projectionBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 32);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.cellToForgetWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 34);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.cellToOutputWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 36);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.inputLayerNormWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 38);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.forgetLayerNormWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 40);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.cellLayerNormWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 42);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.LstmInputParams.prototype.outputLayerNormWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 44);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LstmInputParams.startLstmInputParams = function(builder) {
  builder.startObject(21);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToForgetWeightsOffset
 */
armnnSerializer.LstmInputParams.addInputToForgetWeights = function(builder, inputToForgetWeightsOffset) {
  builder.addFieldOffset(0, inputToForgetWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToCellWeightsOffset
 */
armnnSerializer.LstmInputParams.addInputToCellWeights = function(builder, inputToCellWeightsOffset) {
  builder.addFieldOffset(1, inputToCellWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToOutputWeightsOffset
 */
armnnSerializer.LstmInputParams.addInputToOutputWeights = function(builder, inputToOutputWeightsOffset) {
  builder.addFieldOffset(2, inputToOutputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToForgetWeightsOffset
 */
armnnSerializer.LstmInputParams.addRecurrentToForgetWeights = function(builder, recurrentToForgetWeightsOffset) {
  builder.addFieldOffset(3, recurrentToForgetWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToCellWeightsOffset
 */
armnnSerializer.LstmInputParams.addRecurrentToCellWeights = function(builder, recurrentToCellWeightsOffset) {
  builder.addFieldOffset(4, recurrentToCellWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToOutputWeightsOffset
 */
armnnSerializer.LstmInputParams.addRecurrentToOutputWeights = function(builder, recurrentToOutputWeightsOffset) {
  builder.addFieldOffset(5, recurrentToOutputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} forgetGateBiasOffset
 */
armnnSerializer.LstmInputParams.addForgetGateBias = function(builder, forgetGateBiasOffset) {
  builder.addFieldOffset(6, forgetGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellBiasOffset
 */
armnnSerializer.LstmInputParams.addCellBias = function(builder, cellBiasOffset) {
  builder.addFieldOffset(7, cellBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputGateBiasOffset
 */
armnnSerializer.LstmInputParams.addOutputGateBias = function(builder, outputGateBiasOffset) {
  builder.addFieldOffset(8, outputGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToInputWeightsOffset
 */
armnnSerializer.LstmInputParams.addInputToInputWeights = function(builder, inputToInputWeightsOffset) {
  builder.addFieldOffset(9, inputToInputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToInputWeightsOffset
 */
armnnSerializer.LstmInputParams.addRecurrentToInputWeights = function(builder, recurrentToInputWeightsOffset) {
  builder.addFieldOffset(10, recurrentToInputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellToInputWeightsOffset
 */
armnnSerializer.LstmInputParams.addCellToInputWeights = function(builder, cellToInputWeightsOffset) {
  builder.addFieldOffset(11, cellToInputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputGateBiasOffset
 */
armnnSerializer.LstmInputParams.addInputGateBias = function(builder, inputGateBiasOffset) {
  builder.addFieldOffset(12, inputGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} projectionWeightsOffset
 */
armnnSerializer.LstmInputParams.addProjectionWeights = function(builder, projectionWeightsOffset) {
  builder.addFieldOffset(13, projectionWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} projectionBiasOffset
 */
armnnSerializer.LstmInputParams.addProjectionBias = function(builder, projectionBiasOffset) {
  builder.addFieldOffset(14, projectionBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellToForgetWeightsOffset
 */
armnnSerializer.LstmInputParams.addCellToForgetWeights = function(builder, cellToForgetWeightsOffset) {
  builder.addFieldOffset(15, cellToForgetWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellToOutputWeightsOffset
 */
armnnSerializer.LstmInputParams.addCellToOutputWeights = function(builder, cellToOutputWeightsOffset) {
  builder.addFieldOffset(16, cellToOutputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputLayerNormWeightsOffset
 */
armnnSerializer.LstmInputParams.addInputLayerNormWeights = function(builder, inputLayerNormWeightsOffset) {
  builder.addFieldOffset(17, inputLayerNormWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} forgetLayerNormWeightsOffset
 */
armnnSerializer.LstmInputParams.addForgetLayerNormWeights = function(builder, forgetLayerNormWeightsOffset) {
  builder.addFieldOffset(18, forgetLayerNormWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellLayerNormWeightsOffset
 */
armnnSerializer.LstmInputParams.addCellLayerNormWeights = function(builder, cellLayerNormWeightsOffset) {
  builder.addFieldOffset(19, cellLayerNormWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputLayerNormWeightsOffset
 */
armnnSerializer.LstmInputParams.addOutputLayerNormWeights = function(builder, outputLayerNormWeightsOffset) {
  builder.addFieldOffset(20, outputLayerNormWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmInputParams.endLstmInputParams = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToForgetWeightsOffset
 * @param {flatbuffers.Offset} inputToCellWeightsOffset
 * @param {flatbuffers.Offset} inputToOutputWeightsOffset
 * @param {flatbuffers.Offset} recurrentToForgetWeightsOffset
 * @param {flatbuffers.Offset} recurrentToCellWeightsOffset
 * @param {flatbuffers.Offset} recurrentToOutputWeightsOffset
 * @param {flatbuffers.Offset} forgetGateBiasOffset
 * @param {flatbuffers.Offset} cellBiasOffset
 * @param {flatbuffers.Offset} outputGateBiasOffset
 * @param {flatbuffers.Offset} inputToInputWeightsOffset
 * @param {flatbuffers.Offset} recurrentToInputWeightsOffset
 * @param {flatbuffers.Offset} cellToInputWeightsOffset
 * @param {flatbuffers.Offset} inputGateBiasOffset
 * @param {flatbuffers.Offset} projectionWeightsOffset
 * @param {flatbuffers.Offset} projectionBiasOffset
 * @param {flatbuffers.Offset} cellToForgetWeightsOffset
 * @param {flatbuffers.Offset} cellToOutputWeightsOffset
 * @param {flatbuffers.Offset} inputLayerNormWeightsOffset
 * @param {flatbuffers.Offset} forgetLayerNormWeightsOffset
 * @param {flatbuffers.Offset} cellLayerNormWeightsOffset
 * @param {flatbuffers.Offset} outputLayerNormWeightsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmInputParams.createLstmInputParams = function(builder, inputToForgetWeightsOffset, inputToCellWeightsOffset, inputToOutputWeightsOffset, recurrentToForgetWeightsOffset, recurrentToCellWeightsOffset, recurrentToOutputWeightsOffset, forgetGateBiasOffset, cellBiasOffset, outputGateBiasOffset, inputToInputWeightsOffset, recurrentToInputWeightsOffset, cellToInputWeightsOffset, inputGateBiasOffset, projectionWeightsOffset, projectionBiasOffset, cellToForgetWeightsOffset, cellToOutputWeightsOffset, inputLayerNormWeightsOffset, forgetLayerNormWeightsOffset, cellLayerNormWeightsOffset, outputLayerNormWeightsOffset) {
  armnnSerializer.LstmInputParams.startLstmInputParams(builder);
  armnnSerializer.LstmInputParams.addInputToForgetWeights(builder, inputToForgetWeightsOffset);
  armnnSerializer.LstmInputParams.addInputToCellWeights(builder, inputToCellWeightsOffset);
  armnnSerializer.LstmInputParams.addInputToOutputWeights(builder, inputToOutputWeightsOffset);
  armnnSerializer.LstmInputParams.addRecurrentToForgetWeights(builder, recurrentToForgetWeightsOffset);
  armnnSerializer.LstmInputParams.addRecurrentToCellWeights(builder, recurrentToCellWeightsOffset);
  armnnSerializer.LstmInputParams.addRecurrentToOutputWeights(builder, recurrentToOutputWeightsOffset);
  armnnSerializer.LstmInputParams.addForgetGateBias(builder, forgetGateBiasOffset);
  armnnSerializer.LstmInputParams.addCellBias(builder, cellBiasOffset);
  armnnSerializer.LstmInputParams.addOutputGateBias(builder, outputGateBiasOffset);
  armnnSerializer.LstmInputParams.addInputToInputWeights(builder, inputToInputWeightsOffset);
  armnnSerializer.LstmInputParams.addRecurrentToInputWeights(builder, recurrentToInputWeightsOffset);
  armnnSerializer.LstmInputParams.addCellToInputWeights(builder, cellToInputWeightsOffset);
  armnnSerializer.LstmInputParams.addInputGateBias(builder, inputGateBiasOffset);
  armnnSerializer.LstmInputParams.addProjectionWeights(builder, projectionWeightsOffset);
  armnnSerializer.LstmInputParams.addProjectionBias(builder, projectionBiasOffset);
  armnnSerializer.LstmInputParams.addCellToForgetWeights(builder, cellToForgetWeightsOffset);
  armnnSerializer.LstmInputParams.addCellToOutputWeights(builder, cellToOutputWeightsOffset);
  armnnSerializer.LstmInputParams.addInputLayerNormWeights(builder, inputLayerNormWeightsOffset);
  armnnSerializer.LstmInputParams.addForgetLayerNormWeights(builder, forgetLayerNormWeightsOffset);
  armnnSerializer.LstmInputParams.addCellLayerNormWeights(builder, cellLayerNormWeightsOffset);
  armnnSerializer.LstmInputParams.addOutputLayerNormWeights(builder, outputLayerNormWeightsOffset);
  return armnnSerializer.LstmInputParams.endLstmInputParams(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.QuantizedLstmInputParams.prototype.inputToForgetWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.QuantizedLstmInputParams.prototype.inputToCellWeights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.QuantizedLstmInputParams.prototype.forgetGateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.QuantizedLstmInputParams.prototype.cellBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.QuantizedLstmInputParams.prototype.outputGateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.QuantizedLstmInputParams.startQuantizedLstmInputParams = function(builder) {
  builder.startObject(12);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToInputWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addInputToInputWeights = function(builder, inputToInputWeightsOffset) {
  builder.addFieldOffset(0, inputToInputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToForgetWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addInputToForgetWeights = function(builder, inputToForgetWeightsOffset) {
  builder.addFieldOffset(1, inputToForgetWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToCellWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addInputToCellWeights = function(builder, inputToCellWeightsOffset) {
  builder.addFieldOffset(2, inputToCellWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToOutputWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addInputToOutputWeights = function(builder, inputToOutputWeightsOffset) {
  builder.addFieldOffset(3, inputToOutputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToInputWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addRecurrentToInputWeights = function(builder, recurrentToInputWeightsOffset) {
  builder.addFieldOffset(4, recurrentToInputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToForgetWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addRecurrentToForgetWeights = function(builder, recurrentToForgetWeightsOffset) {
  builder.addFieldOffset(5, recurrentToForgetWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToCellWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addRecurrentToCellWeights = function(builder, recurrentToCellWeightsOffset) {
  builder.addFieldOffset(6, recurrentToCellWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} recurrentToOutputWeightsOffset
 */
armnnSerializer.QuantizedLstmInputParams.addRecurrentToOutputWeights = function(builder, recurrentToOutputWeightsOffset) {
  builder.addFieldOffset(7, recurrentToOutputWeightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputGateBiasOffset
 */
armnnSerializer.QuantizedLstmInputParams.addInputGateBias = function(builder, inputGateBiasOffset) {
  builder.addFieldOffset(8, inputGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} forgetGateBiasOffset
 */
armnnSerializer.QuantizedLstmInputParams.addForgetGateBias = function(builder, forgetGateBiasOffset) {
  builder.addFieldOffset(9, forgetGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} cellBiasOffset
 */
armnnSerializer.QuantizedLstmInputParams.addCellBias = function(builder, cellBiasOffset) {
  builder.addFieldOffset(10, cellBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputGateBiasOffset
 */
armnnSerializer.QuantizedLstmInputParams.addOutputGateBias = function(builder, outputGateBiasOffset) {
  builder.addFieldOffset(11, outputGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizedLstmInputParams.endQuantizedLstmInputParams = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputToInputWeightsOffset
 * @param {flatbuffers.Offset} inputToForgetWeightsOffset
 * @param {flatbuffers.Offset} inputToCellWeightsOffset
 * @param {flatbuffers.Offset} inputToOutputWeightsOffset
 * @param {flatbuffers.Offset} recurrentToInputWeightsOffset
 * @param {flatbuffers.Offset} recurrentToForgetWeightsOffset
 * @param {flatbuffers.Offset} recurrentToCellWeightsOffset
 * @param {flatbuffers.Offset} recurrentToOutputWeightsOffset
 * @param {flatbuffers.Offset} inputGateBiasOffset
 * @param {flatbuffers.Offset} forgetGateBiasOffset
 * @param {flatbuffers.Offset} cellBiasOffset
 * @param {flatbuffers.Offset} outputGateBiasOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizedLstmInputParams.createQuantizedLstmInputParams = function(builder, inputToInputWeightsOffset, inputToForgetWeightsOffset, inputToCellWeightsOffset, inputToOutputWeightsOffset, recurrentToInputWeightsOffset, recurrentToForgetWeightsOffset, recurrentToCellWeightsOffset, recurrentToOutputWeightsOffset, inputGateBiasOffset, forgetGateBiasOffset, cellBiasOffset, outputGateBiasOffset) {
  armnnSerializer.QuantizedLstmInputParams.startQuantizedLstmInputParams(builder);
  armnnSerializer.QuantizedLstmInputParams.addInputToInputWeights(builder, inputToInputWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addInputToForgetWeights(builder, inputToForgetWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addInputToCellWeights(builder, inputToCellWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addInputToOutputWeights(builder, inputToOutputWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addRecurrentToInputWeights(builder, recurrentToInputWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addRecurrentToForgetWeights(builder, recurrentToForgetWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addRecurrentToCellWeights(builder, recurrentToCellWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addRecurrentToOutputWeights(builder, recurrentToOutputWeightsOffset);
  armnnSerializer.QuantizedLstmInputParams.addInputGateBias(builder, inputGateBiasOffset);
  armnnSerializer.QuantizedLstmInputParams.addForgetGateBias(builder, forgetGateBiasOffset);
  armnnSerializer.QuantizedLstmInputParams.addCellBias(builder, cellBiasOffset);
  armnnSerializer.QuantizedLstmInputParams.addOutputGateBias(builder, outputGateBiasOffset);
  return armnnSerializer.QuantizedLstmInputParams.endQuantizedLstmInputParams(builder);
}

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

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

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

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

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

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

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

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

/**
 * @returns {boolean}
 */
armnnSerializer.LstmDescriptor.prototype.cifgEnabled = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true;
};

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LstmDescriptor.startLstmDescriptor = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} activationFunc
 */
armnnSerializer.LstmDescriptor.addActivationFunc = function(builder, activationFunc) {
  builder.addFieldInt32(0, activationFunc, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} clippingThresCell
 */
armnnSerializer.LstmDescriptor.addClippingThresCell = function(builder, clippingThresCell) {
  builder.addFieldFloat32(1, clippingThresCell, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} clippingThresProj
 */
armnnSerializer.LstmDescriptor.addClippingThresProj = function(builder, clippingThresProj) {
  builder.addFieldFloat32(2, clippingThresProj, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} cifgEnabled
 */
armnnSerializer.LstmDescriptor.addCifgEnabled = function(builder, cifgEnabled) {
  builder.addFieldInt8(3, +cifgEnabled, +true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} peepholeEnabled
 */
armnnSerializer.LstmDescriptor.addPeepholeEnabled = function(builder, peepholeEnabled) {
  builder.addFieldInt8(4, +peepholeEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} projectionEnabled
 */
armnnSerializer.LstmDescriptor.addProjectionEnabled = function(builder, projectionEnabled) {
  builder.addFieldInt8(5, +projectionEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} layerNormEnabled
 */
armnnSerializer.LstmDescriptor.addLayerNormEnabled = function(builder, layerNormEnabled) {
  builder.addFieldInt8(6, +layerNormEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmDescriptor.endLstmDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} activationFunc
 * @param {number} clippingThresCell
 * @param {number} clippingThresProj
 * @param {boolean} cifgEnabled
 * @param {boolean} peepholeEnabled
 * @param {boolean} projectionEnabled
 * @param {boolean} layerNormEnabled
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmDescriptor.createLstmDescriptor = function(builder, activationFunc, clippingThresCell, clippingThresProj, cifgEnabled, peepholeEnabled, projectionEnabled, layerNormEnabled) {
  armnnSerializer.LstmDescriptor.startLstmDescriptor(builder);
  armnnSerializer.LstmDescriptor.addActivationFunc(builder, activationFunc);
  armnnSerializer.LstmDescriptor.addClippingThresCell(builder, clippingThresCell);
  armnnSerializer.LstmDescriptor.addClippingThresProj(builder, clippingThresProj);
  armnnSerializer.LstmDescriptor.addCifgEnabled(builder, cifgEnabled);
  armnnSerializer.LstmDescriptor.addPeepholeEnabled(builder, peepholeEnabled);
  armnnSerializer.LstmDescriptor.addProjectionEnabled(builder, projectionEnabled);
  armnnSerializer.LstmDescriptor.addLayerNormEnabled(builder, layerNormEnabled);
  return armnnSerializer.LstmDescriptor.endLstmDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.LstmDescriptor=} obj
 * @returns {armnnSerializer.LstmDescriptor|null}
 */
armnnSerializer.LstmLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.LstmDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.LstmInputParams=} obj
 * @returns {armnnSerializer.LstmInputParams|null}
 */
armnnSerializer.LstmLayer.prototype.inputParams = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.LstmInputParams).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.LstmLayer.startLstmLayer = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.LstmLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.LstmLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputParamsOffset
 */
armnnSerializer.LstmLayer.addInputParams = function(builder, inputParamsOffset) {
  builder.addFieldOffset(2, inputParamsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmLayer.endLstmLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} inputParamsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.LstmLayer.createLstmLayer = function(builder, baseOffset, descriptorOffset, inputParamsOffset) {
  armnnSerializer.LstmLayer.startLstmLayer(builder);
  armnnSerializer.LstmLayer.addBase(builder, baseOffset);
  armnnSerializer.LstmLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.LstmLayer.addInputParams(builder, inputParamsOffset);
  return armnnSerializer.LstmLayer.endLstmLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.QuantizedLstmInputParams=} obj
 * @returns {armnnSerializer.QuantizedLstmInputParams|null}
 */
armnnSerializer.QuantizedLstmLayer.prototype.inputParams = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.QuantizedLstmInputParams).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.QuantizedLstmLayer.startQuantizedLstmLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.QuantizedLstmLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputParamsOffset
 */
armnnSerializer.QuantizedLstmLayer.addInputParams = function(builder, inputParamsOffset) {
  builder.addFieldOffset(1, inputParamsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizedLstmLayer.endQuantizedLstmLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} inputParamsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.QuantizedLstmLayer.createQuantizedLstmLayer = function(builder, baseOffset, inputParamsOffset) {
  armnnSerializer.QuantizedLstmLayer.startQuantizedLstmLayer(builder);
  armnnSerializer.QuantizedLstmLayer.addBase(builder, baseOffset);
  armnnSerializer.QuantizedLstmLayer.addInputParams(builder, inputParamsOffset);
  return armnnSerializer.QuantizedLstmLayer.endQuantizedLstmLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.DequantizeLayer.startDequantizeLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.DequantizeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DequantizeLayer.endDequantizeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.DequantizeLayer.createDequantizeLayer = function(builder, baseOffset) {
  armnnSerializer.DequantizeLayer.startDequantizeLayer(builder);
  armnnSerializer.DequantizeLayer.addBase(builder, baseOffset);
  return armnnSerializer.DequantizeLayer.endDequantizeLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.MergeLayer.startMergeLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.MergeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MergeLayer.endMergeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.MergeLayer.createMergeLayer = function(builder, baseOffset) {
  armnnSerializer.MergeLayer.startMergeLayer(builder);
  armnnSerializer.MergeLayer.addBase(builder, baseOffset);
  return armnnSerializer.MergeLayer.endMergeLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SwitchLayer.startSwitchLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.SwitchLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SwitchLayer.endSwitchLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SwitchLayer.createSwitchLayer = function(builder, baseOffset) {
  armnnSerializer.SwitchLayer.startSwitchLayer(builder);
  armnnSerializer.SwitchLayer.addBase(builder, baseOffset);
  return armnnSerializer.SwitchLayer.endSwitchLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.PreluLayer.startPreluLayer = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.PreluLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PreluLayer.endPreluLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.PreluLayer.createPreluLayer = function(builder, baseOffset) {
  armnnSerializer.PreluLayer.startPreluLayer(builder);
  armnnSerializer.PreluLayer.addBase(builder, baseOffset);
  return armnnSerializer.PreluLayer.endPreluLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.TransposeConvolution2dDescriptor=} obj
 * @returns {armnnSerializer.TransposeConvolution2dDescriptor|null}
 */
armnnSerializer.TransposeConvolution2dLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.TransposeConvolution2dDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {armnnSerializer.ConstTensor=} obj
 * @returns {armnnSerializer.ConstTensor|null}
 */
armnnSerializer.TransposeConvolution2dLayer.prototype.weights = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new armnnSerializer.ConstTensor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.TransposeConvolution2dLayer.startTransposeConvolution2dLayer = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.TransposeConvolution2dLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.TransposeConvolution2dLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightsOffset
 */
armnnSerializer.TransposeConvolution2dLayer.addWeights = function(builder, weightsOffset) {
  builder.addFieldOffset(2, weightsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasesOffset
 */
armnnSerializer.TransposeConvolution2dLayer.addBiases = function(builder, biasesOffset) {
  builder.addFieldOffset(3, biasesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeConvolution2dLayer.endTransposeConvolution2dLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @param {flatbuffers.Offset} weightsOffset
 * @param {flatbuffers.Offset} biasesOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeConvolution2dLayer.createTransposeConvolution2dLayer = function(builder, baseOffset, descriptorOffset, weightsOffset, biasesOffset) {
  armnnSerializer.TransposeConvolution2dLayer.startTransposeConvolution2dLayer(builder);
  armnnSerializer.TransposeConvolution2dLayer.addBase(builder, baseOffset);
  armnnSerializer.TransposeConvolution2dLayer.addDescriptor(builder, descriptorOffset);
  armnnSerializer.TransposeConvolution2dLayer.addWeights(builder, weightsOffset);
  armnnSerializer.TransposeConvolution2dLayer.addBiases(builder, biasesOffset);
  return armnnSerializer.TransposeConvolution2dLayer.endTransposeConvolution2dLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.TransposeConvolution2dDescriptor.prototype.padRight = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {number}
 */
armnnSerializer.TransposeConvolution2dDescriptor.prototype.padBottom = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.TransposeConvolution2dDescriptor.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
armnnSerializer.TransposeConvolution2dDescriptor.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

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

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.TransposeConvolution2dDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.TransposeConvolution2dDescriptor.startTransposeConvolution2dDescriptor = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 */
armnnSerializer.TransposeConvolution2dDescriptor.addPadLeft = function(builder, padLeft) {
  builder.addFieldInt32(0, padLeft, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padRight
 */
armnnSerializer.TransposeConvolution2dDescriptor.addPadRight = function(builder, padRight) {
  builder.addFieldInt32(1, padRight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padTop
 */
armnnSerializer.TransposeConvolution2dDescriptor.addPadTop = function(builder, padTop) {
  builder.addFieldInt32(2, padTop, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padBottom
 */
armnnSerializer.TransposeConvolution2dDescriptor.addPadBottom = function(builder, padBottom) {
  builder.addFieldInt32(3, padBottom, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
armnnSerializer.TransposeConvolution2dDescriptor.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(4, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
armnnSerializer.TransposeConvolution2dDescriptor.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(5, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasEnabled
 */
armnnSerializer.TransposeConvolution2dDescriptor.addBiasEnabled = function(builder, biasEnabled) {
  builder.addFieldInt8(6, +biasEnabled, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.TransposeConvolution2dDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(7, dataLayout, armnnSerializer.DataLayout.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeConvolution2dDescriptor.endTransposeConvolution2dDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padLeft
 * @param {number} padRight
 * @param {number} padTop
 * @param {number} padBottom
 * @param {number} strideX
 * @param {number} strideY
 * @param {boolean} biasEnabled
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeConvolution2dDescriptor.createTransposeConvolution2dDescriptor = function(builder, padLeft, padRight, padTop, padBottom, strideX, strideY, biasEnabled, dataLayout) {
  armnnSerializer.TransposeConvolution2dDescriptor.startTransposeConvolution2dDescriptor(builder);
  armnnSerializer.TransposeConvolution2dDescriptor.addPadLeft(builder, padLeft);
  armnnSerializer.TransposeConvolution2dDescriptor.addPadRight(builder, padRight);
  armnnSerializer.TransposeConvolution2dDescriptor.addPadTop(builder, padTop);
  armnnSerializer.TransposeConvolution2dDescriptor.addPadBottom(builder, padBottom);
  armnnSerializer.TransposeConvolution2dDescriptor.addStrideX(builder, strideX);
  armnnSerializer.TransposeConvolution2dDescriptor.addStrideY(builder, strideY);
  armnnSerializer.TransposeConvolution2dDescriptor.addBiasEnabled(builder, biasEnabled);
  armnnSerializer.TransposeConvolution2dDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.TransposeConvolution2dDescriptor.endTransposeConvolution2dDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.TransposeDescriptor=} obj
 * @returns {armnnSerializer.TransposeDescriptor|null}
 */
armnnSerializer.TransposeLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.TransposeDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.TransposeLayer.startTransposeLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.TransposeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.TransposeLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeLayer.endTransposeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeLayer.createTransposeLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.TransposeLayer.startTransposeLayer(builder);
  armnnSerializer.TransposeLayer.addBase(builder, baseOffset);
  armnnSerializer.TransposeLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.TransposeLayer.endTransposeLayer(builder);
}

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

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

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

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

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

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.TransposeDescriptor.prototype.dimMappings = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.TransposeDescriptor.startTransposeDescriptor = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimMappingsOffset
 */
armnnSerializer.TransposeDescriptor.addDimMappings = function(builder, dimMappingsOffset) {
  builder.addFieldOffset(0, dimMappingsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeDescriptor.endTransposeDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimMappingsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.TransposeDescriptor.createTransposeDescriptor = function(builder, dimMappingsOffset) {
  armnnSerializer.TransposeDescriptor.startTransposeDescriptor(builder);
  armnnSerializer.TransposeDescriptor.addDimMappings(builder, dimMappingsOffset);
  return armnnSerializer.TransposeDescriptor.endTransposeDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.ResizeDescriptor=} obj
 * @returns {armnnSerializer.ResizeDescriptor|null}
 */
armnnSerializer.ResizeLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.ResizeDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ResizeLayer.startResizeLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.ResizeLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.ResizeLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeLayer.endResizeLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeLayer.createResizeLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.ResizeLayer.startResizeLayer(builder);
  armnnSerializer.ResizeLayer.addBase(builder, baseOffset);
  armnnSerializer.ResizeLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.ResizeLayer.endResizeLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.ResizeDescriptor.prototype.targetWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @returns {armnnSerializer.ResizeMethod}
 */
armnnSerializer.ResizeDescriptor.prototype.method = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {armnnSerializer.ResizeMethod} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.ResizeMethod.NearestNeighbor;
};

/**
 * @returns {armnnSerializer.DataLayout}
 */
armnnSerializer.ResizeDescriptor.prototype.dataLayout = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {armnnSerializer.DataLayout} */ (this.bb.readInt8(this.bb_pos + offset)) : armnnSerializer.DataLayout.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.ResizeDescriptor.startResizeDescriptor = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetHeight
 */
armnnSerializer.ResizeDescriptor.addTargetHeight = function(builder, targetHeight) {
  builder.addFieldInt32(0, targetHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetWidth
 */
armnnSerializer.ResizeDescriptor.addTargetWidth = function(builder, targetWidth) {
  builder.addFieldInt32(1, targetWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.ResizeMethod} method
 */
armnnSerializer.ResizeDescriptor.addMethod = function(builder, method) {
  builder.addFieldInt8(2, method, armnnSerializer.ResizeMethod.NearestNeighbor);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.DataLayout} dataLayout
 */
armnnSerializer.ResizeDescriptor.addDataLayout = function(builder, dataLayout) {
  builder.addFieldInt8(3, dataLayout, armnnSerializer.DataLayout.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeDescriptor.endResizeDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} targetHeight
 * @param {number} targetWidth
 * @param {armnnSerializer.ResizeMethod} method
 * @param {armnnSerializer.DataLayout} dataLayout
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.ResizeDescriptor.createResizeDescriptor = function(builder, targetHeight, targetWidth, method, dataLayout) {
  armnnSerializer.ResizeDescriptor.startResizeDescriptor(builder);
  armnnSerializer.ResizeDescriptor.addTargetHeight(builder, targetHeight);
  armnnSerializer.ResizeDescriptor.addTargetWidth(builder, targetWidth);
  armnnSerializer.ResizeDescriptor.addMethod(builder, method);
  armnnSerializer.ResizeDescriptor.addDataLayout(builder, dataLayout);
  return armnnSerializer.ResizeDescriptor.endResizeDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.StackDescriptor=} obj
 * @returns {armnnSerializer.StackDescriptor|null}
 */
armnnSerializer.StackLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.StackDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StackLayer.startStackLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.StackLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.StackLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StackLayer.endStackLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StackLayer.createStackLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.StackLayer.startStackLayer(builder);
  armnnSerializer.StackLayer.addBase(builder, baseOffset);
  armnnSerializer.StackLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.StackLayer.endStackLayer(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.StackDescriptor.prototype.numInputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
armnnSerializer.StackDescriptor.prototype.inputShape = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StackDescriptor.startStackDescriptor = function(builder) {
  builder.startObject(3);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numInputs
 */
armnnSerializer.StackDescriptor.addNumInputs = function(builder, numInputs) {
  builder.addFieldInt32(1, numInputs, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputShapeOffset
 */
armnnSerializer.StackDescriptor.addInputShape = function(builder, inputShapeOffset) {
  builder.addFieldOffset(2, inputShapeOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StackDescriptor.endStackDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @param {number} numInputs
 * @param {flatbuffers.Offset} inputShapeOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StackDescriptor.createStackDescriptor = function(builder, axis, numInputs, inputShapeOffset) {
  armnnSerializer.StackDescriptor.startStackDescriptor(builder);
  armnnSerializer.StackDescriptor.addAxis(builder, axis);
  armnnSerializer.StackDescriptor.addNumInputs(builder, numInputs);
  armnnSerializer.StackDescriptor.addInputShape(builder, inputShapeOffset);
  return armnnSerializer.StackDescriptor.endStackDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @returns {number}
 */
armnnSerializer.StandInDescriptor.prototype.numOutputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StandInDescriptor.startStandInDescriptor = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numInputs
 */
armnnSerializer.StandInDescriptor.addNumInputs = function(builder, numInputs) {
  builder.addFieldInt32(0, numInputs, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numOutputs
 */
armnnSerializer.StandInDescriptor.addNumOutputs = function(builder, numOutputs) {
  builder.addFieldInt32(1, numOutputs, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StandInDescriptor.endStandInDescriptor = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numInputs
 * @param {number} numOutputs
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StandInDescriptor.createStandInDescriptor = function(builder, numInputs, numOutputs) {
  armnnSerializer.StandInDescriptor.startStandInDescriptor(builder);
  armnnSerializer.StandInDescriptor.addNumInputs(builder, numInputs);
  armnnSerializer.StandInDescriptor.addNumOutputs(builder, numOutputs);
  return armnnSerializer.StandInDescriptor.endStandInDescriptor(builder);
}

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

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

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

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

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

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

/**
 * @param {armnnSerializer.StandInDescriptor=} obj
 * @returns {armnnSerializer.StandInDescriptor|null}
 */
armnnSerializer.StandInLayer.prototype.descriptor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new armnnSerializer.StandInDescriptor).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.StandInLayer.startStandInLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 */
armnnSerializer.StandInLayer.addBase = function(builder, baseOffset) {
  builder.addFieldOffset(0, baseOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} descriptorOffset
 */
armnnSerializer.StandInLayer.addDescriptor = function(builder, descriptorOffset) {
  builder.addFieldOffset(1, descriptorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StandInLayer.endStandInLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} baseOffset
 * @param {flatbuffers.Offset} descriptorOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.StandInLayer.createStandInLayer = function(builder, baseOffset, descriptorOffset) {
  armnnSerializer.StandInLayer.startStandInLayer(builder);
  armnnSerializer.StandInLayer.addBase(builder, baseOffset);
  armnnSerializer.StandInLayer.addDescriptor(builder, descriptorOffset);
  return armnnSerializer.StandInLayer.endStandInLayer(builder);
}

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

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

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

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

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

/**
 * @returns {armnnSerializer.Layer}
 */
armnnSerializer.AnyLayer.prototype.layerType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {armnnSerializer.Layer} */ (this.bb.readUint8(this.bb_pos + offset)) : armnnSerializer.Layer.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
armnnSerializer.AnyLayer.prototype.layer = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.AnyLayer.startAnyLayer = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.Layer} layerType
 */
armnnSerializer.AnyLayer.addLayerType = function(builder, layerType) {
  builder.addFieldInt8(0, layerType, armnnSerializer.Layer.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} layerOffset
 */
armnnSerializer.AnyLayer.addLayer = function(builder, layerOffset) {
  builder.addFieldOffset(1, layerOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AnyLayer.endAnyLayer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {armnnSerializer.Layer} layerType
 * @param {flatbuffers.Offset} layerOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.AnyLayer.createAnyLayer = function(builder, layerType, layerOffset) {
  armnnSerializer.AnyLayer.startAnyLayer(builder);
  armnnSerializer.AnyLayer.addLayerType(builder, layerType);
  armnnSerializer.AnyLayer.addLayer(builder, layerOffset);
  return armnnSerializer.AnyLayer.endAnyLayer(builder);
}

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

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

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

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

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

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

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.FeatureCompatibilityVersions.startFeatureCompatibilityVersions = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} bindingIdsScheme
 */
armnnSerializer.FeatureCompatibilityVersions.addBindingIdsScheme = function(builder, bindingIdsScheme) {
  builder.addFieldInt32(0, bindingIdsScheme, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FeatureCompatibilityVersions.endFeatureCompatibilityVersions = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} bindingIdsScheme
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.FeatureCompatibilityVersions.createFeatureCompatibilityVersions = function(builder, bindingIdsScheme) {
  armnnSerializer.FeatureCompatibilityVersions.startFeatureCompatibilityVersions(builder);
  armnnSerializer.FeatureCompatibilityVersions.addBindingIdsScheme(builder, bindingIdsScheme);
  return armnnSerializer.FeatureCompatibilityVersions.endFeatureCompatibilityVersions(builder);
}

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

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

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

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

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

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {boolean}
 */
armnnSerializer.SerializedGraph.bufferHasIdentifier = function(bb) {
  return bb.__has_identifier('ARMN');
};

/**
 * @param {number} index
 * @param {armnnSerializer.AnyLayer=} obj
 * @returns {armnnSerializer.AnyLayer}
 */
armnnSerializer.SerializedGraph.prototype.layers = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new armnnSerializer.AnyLayer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
armnnSerializer.SerializedGraph.prototype.layersLength = 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}
 */
armnnSerializer.SerializedGraph.prototype.inputIds = 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}
 */
armnnSerializer.SerializedGraph.prototype.inputIdsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
armnnSerializer.SerializedGraph.prototype.inputIdsArray = 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}
 */
armnnSerializer.SerializedGraph.prototype.outputIds = 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}
 */
armnnSerializer.SerializedGraph.prototype.outputIdsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
armnnSerializer.SerializedGraph.prototype.outputIdsArray = 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 {armnnSerializer.FeatureCompatibilityVersions=} obj
 * @returns {armnnSerializer.FeatureCompatibilityVersions|null}
 */
armnnSerializer.SerializedGraph.prototype.featureVersions = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new armnnSerializer.FeatureCompatibilityVersions).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
armnnSerializer.SerializedGraph.startSerializedGraph = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} layersOffset
 */
armnnSerializer.SerializedGraph.addLayers = function(builder, layersOffset) {
  builder.addFieldOffset(0, layersOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SerializedGraph.createLayersVector = 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
 */
armnnSerializer.SerializedGraph.startLayersVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputIdsOffset
 */
armnnSerializer.SerializedGraph.addInputIds = function(builder, inputIdsOffset) {
  builder.addFieldOffset(1, inputIdsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputIdsOffset
 */
armnnSerializer.SerializedGraph.addOutputIds = function(builder, outputIdsOffset) {
  builder.addFieldOffset(2, outputIdsOffset, 0);
};

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

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} featureVersionsOffset
 */
armnnSerializer.SerializedGraph.addFeatureVersions = function(builder, featureVersionsOffset) {
  builder.addFieldOffset(3, featureVersionsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SerializedGraph.endSerializedGraph = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
armnnSerializer.SerializedGraph.finishSerializedGraphBuffer = function(builder, offset) {
  builder.finish(offset, 'ARMN');
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
armnnSerializer.SerializedGraph.finishSizePrefixedSerializedGraphBuffer = function(builder, offset) {
  builder.finish(offset, 'ARMN', true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} layersOffset
 * @param {flatbuffers.Offset} inputIdsOffset
 * @param {flatbuffers.Offset} outputIdsOffset
 * @param {flatbuffers.Offset} featureVersionsOffset
 * @returns {flatbuffers.Offset}
 */
armnnSerializer.SerializedGraph.createSerializedGraph = function(builder, layersOffset, inputIdsOffset, outputIdsOffset, featureVersionsOffset) {
  armnnSerializer.SerializedGraph.startSerializedGraph(builder);
  armnnSerializer.SerializedGraph.addLayers(builder, layersOffset);
  armnnSerializer.SerializedGraph.addInputIds(builder, inputIdsOffset);
  armnnSerializer.SerializedGraph.addOutputIds(builder, outputIdsOffset);
  armnnSerializer.SerializedGraph.addFeatureVersions(builder, featureVersionsOffset);
  return armnnSerializer.SerializedGraph.endSerializedGraph(builder);
}

if (typeof module !== 'undefined' && typeof module.exports === 'object') {
  module.exports = armnnSerializer;
}
