// automatically generated by the FlatBuffers compiler, do not modify
//
// To reproduce:
//   flatc version 24.12.23
//   schema.fbs @v2.18.0
//   flatc --cpp --scoped-enums --reflect-names --gen-mutable schema.fbs
//   sed -i 's/ARG_MAX/ARGMAX/g' tflite_schema_generated.hpp


#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 12 &&
              FLATBUFFERS_VERSION_REVISION == 23,
             "Non-compatible flatbuffers version included");

namespace tflite {

struct CustomQuantization;
struct CustomQuantizationBuilder;

struct QuantizationParameters;
struct QuantizationParametersBuilder;

struct Int32Vector;
struct Int32VectorBuilder;

struct Uint16Vector;
struct Uint16VectorBuilder;

struct Uint8Vector;
struct Uint8VectorBuilder;

struct DimensionMetadata;
struct DimensionMetadataBuilder;

struct SparsityParameters;
struct SparsityParametersBuilder;

struct VariantSubType;
struct VariantSubTypeBuilder;

struct Tensor;
struct TensorBuilder;

struct StablehloGatherOptions;
struct StablehloGatherOptionsBuilder;

struct StablehloTransposeOptions;
struct StablehloTransposeOptionsBuilder;

struct StablehloDotGeneralOptions;
struct StablehloDotGeneralOptionsBuilder;

struct StablehloReduceWindowOptions;
struct StablehloReduceWindowOptionsBuilder;

struct StablehloWhileOptions;
struct StablehloWhileOptionsBuilder;

struct StablehloSortOptions;
struct StablehloSortOptionsBuilder;

struct StablehloConcatenateOptions;
struct StablehloConcatenateOptionsBuilder;

struct StablehloBroadcastInDimOptions;
struct StablehloBroadcastInDimOptionsBuilder;

struct StablehloCompareOptions;
struct StablehloCompareOptionsBuilder;

struct StablehloDynamicSliceOptions;
struct StablehloDynamicSliceOptionsBuilder;

struct StablehloPadOptions;
struct StablehloPadOptionsBuilder;

struct StablehloIotaOptions;
struct StablehloIotaOptionsBuilder;

struct StablehloCustomCallOptions;
struct StablehloCustomCallOptionsBuilder;

struct StablehloReduceOptions;
struct StablehloReduceOptionsBuilder;

struct StablehloSliceOptions;
struct StablehloSliceOptionsBuilder;

struct StablehloConvolutionOptions;
struct StablehloConvolutionOptionsBuilder;

struct StablehloScatterOptions;
struct StablehloScatterOptionsBuilder;

struct StablehloRngBitGeneratorOptions;
struct StablehloRngBitGeneratorOptionsBuilder;

struct Conv2DOptions;
struct Conv2DOptionsBuilder;

struct Conv3DOptions;
struct Conv3DOptionsBuilder;

struct Pool2DOptions;
struct Pool2DOptionsBuilder;

struct DepthwiseConv2DOptions;
struct DepthwiseConv2DOptionsBuilder;

struct ConcatEmbeddingsOptions;
struct ConcatEmbeddingsOptionsBuilder;

struct LSHProjectionOptions;
struct LSHProjectionOptionsBuilder;

struct SVDFOptions;
struct SVDFOptionsBuilder;

struct RNNOptions;
struct RNNOptionsBuilder;

struct SequenceRNNOptions;
struct SequenceRNNOptionsBuilder;

struct BidirectionalSequenceRNNOptions;
struct BidirectionalSequenceRNNOptionsBuilder;

struct FullyConnectedOptions;
struct FullyConnectedOptionsBuilder;

struct SoftmaxOptions;
struct SoftmaxOptionsBuilder;

struct ConcatenationOptions;
struct ConcatenationOptionsBuilder;

struct AddOptions;
struct AddOptionsBuilder;

struct MulOptions;
struct MulOptionsBuilder;

struct L2NormOptions;
struct L2NormOptionsBuilder;

struct LocalResponseNormalizationOptions;
struct LocalResponseNormalizationOptionsBuilder;

struct LSTMOptions;
struct LSTMOptionsBuilder;

struct UnidirectionalSequenceLSTMOptions;
struct UnidirectionalSequenceLSTMOptionsBuilder;

struct BidirectionalSequenceLSTMOptions;
struct BidirectionalSequenceLSTMOptionsBuilder;

struct ResizeBilinearOptions;
struct ResizeBilinearOptionsBuilder;

struct ResizeNearestNeighborOptions;
struct ResizeNearestNeighborOptionsBuilder;

struct CallOptions;
struct CallOptionsBuilder;

struct PadOptions;
struct PadOptionsBuilder;

struct PadV2Options;
struct PadV2OptionsBuilder;

struct ReshapeOptions;
struct ReshapeOptionsBuilder;

struct SpaceToBatchNDOptions;
struct SpaceToBatchNDOptionsBuilder;

struct BatchToSpaceNDOptions;
struct BatchToSpaceNDOptionsBuilder;

struct SkipGramOptions;
struct SkipGramOptionsBuilder;

struct SpaceToDepthOptions;
struct SpaceToDepthOptionsBuilder;

struct DepthToSpaceOptions;
struct DepthToSpaceOptionsBuilder;

struct SubOptions;
struct SubOptionsBuilder;

struct DivOptions;
struct DivOptionsBuilder;

struct TopKV2Options;
struct TopKV2OptionsBuilder;

struct EmbeddingLookupSparseOptions;
struct EmbeddingLookupSparseOptionsBuilder;

struct GatherOptions;
struct GatherOptionsBuilder;

struct TransposeOptions;
struct TransposeOptionsBuilder;

struct ExpOptions;
struct ExpOptionsBuilder;

struct CosOptions;
struct CosOptionsBuilder;

struct ReducerOptions;
struct ReducerOptionsBuilder;

struct SqueezeOptions;
struct SqueezeOptionsBuilder;

struct SplitOptions;
struct SplitOptionsBuilder;

struct SplitVOptions;
struct SplitVOptionsBuilder;

struct StridedSliceOptions;
struct StridedSliceOptionsBuilder;

struct LogSoftmaxOptions;
struct LogSoftmaxOptionsBuilder;

struct CastOptions;
struct CastOptionsBuilder;

struct DequantizeOptions;
struct DequantizeOptionsBuilder;

struct MaximumMinimumOptions;
struct MaximumMinimumOptionsBuilder;

struct TileOptions;
struct TileOptionsBuilder;

struct ArgMaxOptions;
struct ArgMaxOptionsBuilder;

struct ArgMinOptions;
struct ArgMinOptionsBuilder;

struct GreaterOptions;
struct GreaterOptionsBuilder;

struct GreaterEqualOptions;
struct GreaterEqualOptionsBuilder;

struct LessOptions;
struct LessOptionsBuilder;

struct LessEqualOptions;
struct LessEqualOptionsBuilder;

struct NegOptions;
struct NegOptionsBuilder;

struct SelectOptions;
struct SelectOptionsBuilder;

struct SliceOptions;
struct SliceOptionsBuilder;

struct TransposeConvOptions;
struct TransposeConvOptionsBuilder;

struct ExpandDimsOptions;
struct ExpandDimsOptionsBuilder;

struct SparseToDenseOptions;
struct SparseToDenseOptionsBuilder;

struct EqualOptions;
struct EqualOptionsBuilder;

struct NotEqualOptions;
struct NotEqualOptionsBuilder;

struct ShapeOptions;
struct ShapeOptionsBuilder;

struct RankOptions;
struct RankOptionsBuilder;

struct PowOptions;
struct PowOptionsBuilder;

struct FakeQuantOptions;
struct FakeQuantOptionsBuilder;

struct PackOptions;
struct PackOptionsBuilder;

struct LogicalOrOptions;
struct LogicalOrOptionsBuilder;

struct OneHotOptions;
struct OneHotOptionsBuilder;

struct AbsOptions;
struct AbsOptionsBuilder;

struct HardSwishOptions;
struct HardSwishOptionsBuilder;

struct LogicalAndOptions;
struct LogicalAndOptionsBuilder;

struct LogicalNotOptions;
struct LogicalNotOptionsBuilder;

struct UnpackOptions;
struct UnpackOptionsBuilder;

struct FloorDivOptions;
struct FloorDivOptionsBuilder;

struct SquareOptions;
struct SquareOptionsBuilder;

struct ZerosLikeOptions;
struct ZerosLikeOptionsBuilder;

struct FillOptions;
struct FillOptionsBuilder;

struct FloorModOptions;
struct FloorModOptionsBuilder;

struct RangeOptions;
struct RangeOptionsBuilder;

struct LeakyReluOptions;
struct LeakyReluOptionsBuilder;

struct SquaredDifferenceOptions;
struct SquaredDifferenceOptionsBuilder;

struct MirrorPadOptions;
struct MirrorPadOptionsBuilder;

struct UniqueOptions;
struct UniqueOptionsBuilder;

struct ReverseV2Options;
struct ReverseV2OptionsBuilder;

struct AddNOptions;
struct AddNOptionsBuilder;

struct GatherNdOptions;
struct GatherNdOptionsBuilder;

struct WhereOptions;
struct WhereOptionsBuilder;

struct ReverseSequenceOptions;
struct ReverseSequenceOptionsBuilder;

struct MatrixDiagOptions;
struct MatrixDiagOptionsBuilder;

struct QuantizeOptions;
struct QuantizeOptionsBuilder;

struct MatrixSetDiagOptions;
struct MatrixSetDiagOptionsBuilder;

struct IfOptions;
struct IfOptionsBuilder;

struct CallOnceOptions;
struct CallOnceOptionsBuilder;

struct WhileOptions;
struct WhileOptionsBuilder;

struct NonMaxSuppressionV4Options;
struct NonMaxSuppressionV4OptionsBuilder;

struct NonMaxSuppressionV5Options;
struct NonMaxSuppressionV5OptionsBuilder;

struct ScatterNdOptions;
struct ScatterNdOptionsBuilder;

struct SelectV2Options;
struct SelectV2OptionsBuilder;

struct DensifyOptions;
struct DensifyOptionsBuilder;

struct SegmentSumOptions;
struct SegmentSumOptionsBuilder;

struct BatchMatMulOptions;
struct BatchMatMulOptionsBuilder;

struct CumsumOptions;
struct CumsumOptionsBuilder;

struct BroadcastToOptions;
struct BroadcastToOptionsBuilder;

struct Rfft2dOptions;
struct Rfft2dOptionsBuilder;

struct HashtableOptions;
struct HashtableOptionsBuilder;

struct HashtableFindOptions;
struct HashtableFindOptionsBuilder;

struct HashtableImportOptions;
struct HashtableImportOptionsBuilder;

struct HashtableSizeOptions;
struct HashtableSizeOptionsBuilder;

struct VarHandleOptions;
struct VarHandleOptionsBuilder;

struct ReadVariableOptions;
struct ReadVariableOptionsBuilder;

struct AssignVariableOptions;
struct AssignVariableOptionsBuilder;

struct RandomOptions;
struct RandomOptionsBuilder;

struct BucketizeOptions;
struct BucketizeOptionsBuilder;

struct GeluOptions;
struct GeluOptionsBuilder;

struct DynamicUpdateSliceOptions;
struct DynamicUpdateSliceOptionsBuilder;

struct UnsortedSegmentProdOptions;
struct UnsortedSegmentProdOptionsBuilder;

struct UnsortedSegmentMaxOptions;
struct UnsortedSegmentMaxOptionsBuilder;

struct UnsortedSegmentSumOptions;
struct UnsortedSegmentSumOptionsBuilder;

struct ATan2Options;
struct ATan2OptionsBuilder;

struct UnsortedSegmentMinOptions;
struct UnsortedSegmentMinOptionsBuilder;

struct SignOptions;
struct SignOptionsBuilder;

struct BitcastOptions;
struct BitcastOptionsBuilder;

struct BitwiseXorOptions;
struct BitwiseXorOptionsBuilder;

struct RightShiftOptions;
struct RightShiftOptionsBuilder;

struct DilateOptions;
struct DilateOptionsBuilder;

struct ReduceWindowOptions;
struct ReduceWindowOptionsBuilder;

struct OperatorCode;
struct OperatorCodeBuilder;

struct StableHLOCompositeOptions;
struct StableHLOCompositeOptionsBuilder;

struct StablehloShiftLeftOptions;
struct StablehloShiftLeftOptionsBuilder;

struct Operator;
struct OperatorBuilder;

struct SubGraph;
struct SubGraphBuilder;

struct Buffer;
struct BufferBuilder;

struct Metadata;
struct MetadataBuilder;

struct TensorMap;
struct TensorMapBuilder;

struct SignatureDef;
struct SignatureDefBuilder;

struct Model;
struct ModelBuilder;

inline const ::flatbuffers::TypeTable *CustomQuantizationTypeTable();

inline const ::flatbuffers::TypeTable *QuantizationParametersTypeTable();

inline const ::flatbuffers::TypeTable *Int32VectorTypeTable();

inline const ::flatbuffers::TypeTable *Uint16VectorTypeTable();

inline const ::flatbuffers::TypeTable *Uint8VectorTypeTable();

inline const ::flatbuffers::TypeTable *DimensionMetadataTypeTable();

inline const ::flatbuffers::TypeTable *SparsityParametersTypeTable();

inline const ::flatbuffers::TypeTable *VariantSubTypeTypeTable();

inline const ::flatbuffers::TypeTable *TensorTypeTable();

inline const ::flatbuffers::TypeTable *StablehloGatherOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloTransposeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloDotGeneralOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloReduceWindowOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloWhileOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloSortOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloConcatenateOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloBroadcastInDimOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloCompareOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloDynamicSliceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloPadOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloIotaOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloCustomCallOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloReduceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloSliceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloConvolutionOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloScatterOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloRngBitGeneratorOptionsTypeTable();

inline const ::flatbuffers::TypeTable *Conv2DOptionsTypeTable();

inline const ::flatbuffers::TypeTable *Conv3DOptionsTypeTable();

inline const ::flatbuffers::TypeTable *Pool2DOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DepthwiseConv2DOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ConcatEmbeddingsOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LSHProjectionOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SVDFOptionsTypeTable();

inline const ::flatbuffers::TypeTable *RNNOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SequenceRNNOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BidirectionalSequenceRNNOptionsTypeTable();

inline const ::flatbuffers::TypeTable *FullyConnectedOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SoftmaxOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ConcatenationOptionsTypeTable();

inline const ::flatbuffers::TypeTable *AddOptionsTypeTable();

inline const ::flatbuffers::TypeTable *MulOptionsTypeTable();

inline const ::flatbuffers::TypeTable *L2NormOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LocalResponseNormalizationOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LSTMOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnidirectionalSequenceLSTMOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BidirectionalSequenceLSTMOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ResizeBilinearOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ResizeNearestNeighborOptionsTypeTable();

inline const ::flatbuffers::TypeTable *CallOptionsTypeTable();

inline const ::flatbuffers::TypeTable *PadOptionsTypeTable();

inline const ::flatbuffers::TypeTable *PadV2OptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReshapeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SpaceToBatchNDOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BatchToSpaceNDOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SkipGramOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SpaceToDepthOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DepthToSpaceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SubOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DivOptionsTypeTable();

inline const ::flatbuffers::TypeTable *TopKV2OptionsTypeTable();

inline const ::flatbuffers::TypeTable *EmbeddingLookupSparseOptionsTypeTable();

inline const ::flatbuffers::TypeTable *GatherOptionsTypeTable();

inline const ::flatbuffers::TypeTable *TransposeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ExpOptionsTypeTable();

inline const ::flatbuffers::TypeTable *CosOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReducerOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SqueezeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SplitOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SplitVOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StridedSliceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LogSoftmaxOptionsTypeTable();

inline const ::flatbuffers::TypeTable *CastOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DequantizeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *MaximumMinimumOptionsTypeTable();

inline const ::flatbuffers::TypeTable *TileOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ArgMaxOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ArgMinOptionsTypeTable();

inline const ::flatbuffers::TypeTable *GreaterOptionsTypeTable();

inline const ::flatbuffers::TypeTable *GreaterEqualOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LessOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LessEqualOptionsTypeTable();

inline const ::flatbuffers::TypeTable *NegOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SelectOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SliceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *TransposeConvOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ExpandDimsOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SparseToDenseOptionsTypeTable();

inline const ::flatbuffers::TypeTable *EqualOptionsTypeTable();

inline const ::flatbuffers::TypeTable *NotEqualOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ShapeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *RankOptionsTypeTable();

inline const ::flatbuffers::TypeTable *PowOptionsTypeTable();

inline const ::flatbuffers::TypeTable *FakeQuantOptionsTypeTable();

inline const ::flatbuffers::TypeTable *PackOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LogicalOrOptionsTypeTable();

inline const ::flatbuffers::TypeTable *OneHotOptionsTypeTable();

inline const ::flatbuffers::TypeTable *AbsOptionsTypeTable();

inline const ::flatbuffers::TypeTable *HardSwishOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LogicalAndOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LogicalNotOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnpackOptionsTypeTable();

inline const ::flatbuffers::TypeTable *FloorDivOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SquareOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ZerosLikeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *FillOptionsTypeTable();

inline const ::flatbuffers::TypeTable *FloorModOptionsTypeTable();

inline const ::flatbuffers::TypeTable *RangeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *LeakyReluOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SquaredDifferenceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *MirrorPadOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UniqueOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReverseV2OptionsTypeTable();

inline const ::flatbuffers::TypeTable *AddNOptionsTypeTable();

inline const ::flatbuffers::TypeTable *GatherNdOptionsTypeTable();

inline const ::flatbuffers::TypeTable *WhereOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReverseSequenceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *MatrixDiagOptionsTypeTable();

inline const ::flatbuffers::TypeTable *QuantizeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *MatrixSetDiagOptionsTypeTable();

inline const ::flatbuffers::TypeTable *IfOptionsTypeTable();

inline const ::flatbuffers::TypeTable *CallOnceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *WhileOptionsTypeTable();

inline const ::flatbuffers::TypeTable *NonMaxSuppressionV4OptionsTypeTable();

inline const ::flatbuffers::TypeTable *NonMaxSuppressionV5OptionsTypeTable();

inline const ::flatbuffers::TypeTable *ScatterNdOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SelectV2OptionsTypeTable();

inline const ::flatbuffers::TypeTable *DensifyOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SegmentSumOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BatchMatMulOptionsTypeTable();

inline const ::flatbuffers::TypeTable *CumsumOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BroadcastToOptionsTypeTable();

inline const ::flatbuffers::TypeTable *Rfft2dOptionsTypeTable();

inline const ::flatbuffers::TypeTable *HashtableOptionsTypeTable();

inline const ::flatbuffers::TypeTable *HashtableFindOptionsTypeTable();

inline const ::flatbuffers::TypeTable *HashtableImportOptionsTypeTable();

inline const ::flatbuffers::TypeTable *HashtableSizeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *VarHandleOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReadVariableOptionsTypeTable();

inline const ::flatbuffers::TypeTable *AssignVariableOptionsTypeTable();

inline const ::flatbuffers::TypeTable *RandomOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BucketizeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *GeluOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DynamicUpdateSliceOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnsortedSegmentProdOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnsortedSegmentMaxOptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnsortedSegmentSumOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ATan2OptionsTypeTable();

inline const ::flatbuffers::TypeTable *UnsortedSegmentMinOptionsTypeTable();

inline const ::flatbuffers::TypeTable *SignOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BitcastOptionsTypeTable();

inline const ::flatbuffers::TypeTable *BitwiseXorOptionsTypeTable();

inline const ::flatbuffers::TypeTable *RightShiftOptionsTypeTable();

inline const ::flatbuffers::TypeTable *DilateOptionsTypeTable();

inline const ::flatbuffers::TypeTable *ReduceWindowOptionsTypeTable();

inline const ::flatbuffers::TypeTable *OperatorCodeTypeTable();

inline const ::flatbuffers::TypeTable *StableHLOCompositeOptionsTypeTable();

inline const ::flatbuffers::TypeTable *StablehloShiftLeftOptionsTypeTable();

inline const ::flatbuffers::TypeTable *OperatorTypeTable();

inline const ::flatbuffers::TypeTable *SubGraphTypeTable();

inline const ::flatbuffers::TypeTable *BufferTypeTable();

inline const ::flatbuffers::TypeTable *MetadataTypeTable();

inline const ::flatbuffers::TypeTable *TensorMapTypeTable();

inline const ::flatbuffers::TypeTable *SignatureDefTypeTable();

inline const ::flatbuffers::TypeTable *ModelTypeTable();

enum class TensorType : int8_t {
  FLOAT32 = 0,
  FLOAT16 = 1,
  INT32 = 2,
  UINT8 = 3,
  INT64 = 4,
  STRING = 5,
  BOOL = 6,
  INT16 = 7,
  COMPLEX64 = 8,
  INT8 = 9,
  FLOAT64 = 10,
  COMPLEX128 = 11,
  UINT64 = 12,
  RESOURCE = 13,
  VARIANT = 14,
  UINT32 = 15,
  UINT16 = 16,
  INT4 = 17,
  BFLOAT16 = 18,
  MIN = FLOAT32,
  MAX = BFLOAT16
};

inline const TensorType (&EnumValuesTensorType())[19] {
  static const TensorType values[] = {
    TensorType::FLOAT32,
    TensorType::FLOAT16,
    TensorType::INT32,
    TensorType::UINT8,
    TensorType::INT64,
    TensorType::STRING,
    TensorType::BOOL,
    TensorType::INT16,
    TensorType::COMPLEX64,
    TensorType::INT8,
    TensorType::FLOAT64,
    TensorType::COMPLEX128,
    TensorType::UINT64,
    TensorType::RESOURCE,
    TensorType::VARIANT,
    TensorType::UINT32,
    TensorType::UINT16,
    TensorType::INT4,
    TensorType::BFLOAT16
  };
  return values;
}

inline const char * const *EnumNamesTensorType() {
  static const char * const names[20] = {
    "FLOAT32",
    "FLOAT16",
    "INT32",
    "UINT8",
    "INT64",
    "STRING",
    "BOOL",
    "INT16",
    "COMPLEX64",
    "INT8",
    "FLOAT64",
    "COMPLEX128",
    "UINT64",
    "RESOURCE",
    "VARIANT",
    "UINT32",
    "UINT16",
    "INT4",
    "BFLOAT16",
    nullptr
  };
  return names;
}

inline const char *EnumNameTensorType(TensorType e) {
  if (::flatbuffers::IsOutRange(e, TensorType::FLOAT32, TensorType::BFLOAT16)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTensorType()[index];
}

enum class QuantizationDetails : uint8_t {
  NONE = 0,
  CustomQuantization = 1,
  MIN = NONE,
  MAX = CustomQuantization
};

inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2] {
  static const QuantizationDetails values[] = {
    QuantizationDetails::NONE,
    QuantizationDetails::CustomQuantization
  };
  return values;
}

inline const char * const *EnumNamesQuantizationDetails() {
  static const char * const names[3] = {
    "NONE",
    "CustomQuantization",
    nullptr
  };
  return names;
}

inline const char *EnumNameQuantizationDetails(QuantizationDetails e) {
  if (::flatbuffers::IsOutRange(e, QuantizationDetails::NONE, QuantizationDetails::CustomQuantization)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesQuantizationDetails()[index];
}

template<typename T> struct QuantizationDetailsTraits {
  static const QuantizationDetails enum_value = QuantizationDetails::NONE;
};

template<> struct QuantizationDetailsTraits<tflite::CustomQuantization> {
  static const QuantizationDetails enum_value = QuantizationDetails::CustomQuantization;
};

bool VerifyQuantizationDetails(::flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationDetails> *types);

enum class DimensionType : int8_t {
  DENSE = 0,
  SPARSE_CSR = 1,
  MIN = DENSE,
  MAX = SPARSE_CSR
};

inline const DimensionType (&EnumValuesDimensionType())[2] {
  static const DimensionType values[] = {
    DimensionType::DENSE,
    DimensionType::SPARSE_CSR
  };
  return values;
}

inline const char * const *EnumNamesDimensionType() {
  static const char * const names[3] = {
    "DENSE",
    "SPARSE_CSR",
    nullptr
  };
  return names;
}

inline const char *EnumNameDimensionType(DimensionType e) {
  if (::flatbuffers::IsOutRange(e, DimensionType::DENSE, DimensionType::SPARSE_CSR)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDimensionType()[index];
}

enum class SparseIndexVector : uint8_t {
  NONE = 0,
  Int32Vector = 1,
  Uint16Vector = 2,
  Uint8Vector = 3,
  MIN = NONE,
  MAX = Uint8Vector
};

inline const SparseIndexVector (&EnumValuesSparseIndexVector())[4] {
  static const SparseIndexVector values[] = {
    SparseIndexVector::NONE,
    SparseIndexVector::Int32Vector,
    SparseIndexVector::Uint16Vector,
    SparseIndexVector::Uint8Vector
  };
  return values;
}

inline const char * const *EnumNamesSparseIndexVector() {
  static const char * const names[5] = {
    "NONE",
    "Int32Vector",
    "Uint16Vector",
    "Uint8Vector",
    nullptr
  };
  return names;
}

inline const char *EnumNameSparseIndexVector(SparseIndexVector e) {
  if (::flatbuffers::IsOutRange(e, SparseIndexVector::NONE, SparseIndexVector::Uint8Vector)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSparseIndexVector()[index];
}

template<typename T> struct SparseIndexVectorTraits {
  static const SparseIndexVector enum_value = SparseIndexVector::NONE;
};

template<> struct SparseIndexVectorTraits<tflite::Int32Vector> {
  static const SparseIndexVector enum_value = SparseIndexVector::Int32Vector;
};

template<> struct SparseIndexVectorTraits<tflite::Uint16Vector> {
  static const SparseIndexVector enum_value = SparseIndexVector::Uint16Vector;
};

template<> struct SparseIndexVectorTraits<tflite::Uint8Vector> {
  static const SparseIndexVector enum_value = SparseIndexVector::Uint8Vector;
};

bool VerifySparseIndexVector(::flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<SparseIndexVector> *types);

enum class BuiltinOperator : int32_t {
  ADD = 0,
  AVERAGE_POOL_2D = 1,
  CONCATENATION = 2,
  CONV_2D = 3,
  DEPTHWISE_CONV_2D = 4,
  DEPTH_TO_SPACE = 5,
  DEQUANTIZE = 6,
  EMBEDDING_LOOKUP = 7,
  FLOOR = 8,
  FULLY_CONNECTED = 9,
  HASHTABLE_LOOKUP = 10,
  L2_NORMALIZATION = 11,
  L2_POOL_2D = 12,
  LOCAL_RESPONSE_NORMALIZATION = 13,
  LOGISTIC = 14,
  LSH_PROJECTION = 15,
  LSTM = 16,
  MAX_POOL_2D = 17,
  MUL = 18,
  RELU = 19,
  RELU_N1_TO_1 = 20,
  RELU6 = 21,
  RESHAPE = 22,
  RESIZE_BILINEAR = 23,
  RNN = 24,
  SOFTMAX = 25,
  SPACE_TO_DEPTH = 26,
  SVDF = 27,
  TANH = 28,
  CONCAT_EMBEDDINGS = 29,
  SKIP_GRAM = 30,
  CALL = 31,
  CUSTOM = 32,
  EMBEDDING_LOOKUP_SPARSE = 33,
  PAD = 34,
  UNIDIRECTIONAL_SEQUENCE_RNN = 35,
  GATHER = 36,
  BATCH_TO_SPACE_ND = 37,
  SPACE_TO_BATCH_ND = 38,
  TRANSPOSE = 39,
  MEAN = 40,
  SUB = 41,
  DIV = 42,
  SQUEEZE = 43,
  UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
  STRIDED_SLICE = 45,
  BIDIRECTIONAL_SEQUENCE_RNN = 46,
  EXP = 47,
  TOPK_V2 = 48,
  SPLIT = 49,
  LOG_SOFTMAX = 50,
  DELEGATE = 51,
  BIDIRECTIONAL_SEQUENCE_LSTM = 52,
  CAST = 53,
  PRELU = 54,
  MAXIMUM = 55,
  ARGMAX = 56,
  MINIMUM = 57,
  LESS = 58,
  NEG = 59,
  PADV2 = 60,
  GREATER = 61,
  GREATER_EQUAL = 62,
  LESS_EQUAL = 63,
  SELECT = 64,
  SLICE = 65,
  SIN = 66,
  TRANSPOSE_CONV = 67,
  SPARSE_TO_DENSE = 68,
  TILE = 69,
  EXPAND_DIMS = 70,
  EQUAL = 71,
  NOT_EQUAL = 72,
  LOG = 73,
  SUM = 74,
  SQRT = 75,
  RSQRT = 76,
  SHAPE = 77,
  POW = 78,
  ARG_MIN = 79,
  FAKE_QUANT = 80,
  REDUCE_PROD = 81,
  REDUCE_MAX = 82,
  PACK = 83,
  LOGICAL_OR = 84,
  ONE_HOT = 85,
  LOGICAL_AND = 86,
  LOGICAL_NOT = 87,
  UNPACK = 88,
  REDUCE_MIN = 89,
  FLOOR_DIV = 90,
  REDUCE_ANY = 91,
  SQUARE = 92,
  ZEROS_LIKE = 93,
  FILL = 94,
  FLOOR_MOD = 95,
  RANGE = 96,
  RESIZE_NEAREST_NEIGHBOR = 97,
  LEAKY_RELU = 98,
  SQUARED_DIFFERENCE = 99,
  MIRROR_PAD = 100,
  ABS = 101,
  SPLIT_V = 102,
  UNIQUE = 103,
  CEIL = 104,
  REVERSE_V2 = 105,
  ADD_N = 106,
  GATHER_ND = 107,
  COS = 108,
  WHERE = 109,
  RANK = 110,
  ELU = 111,
  REVERSE_SEQUENCE = 112,
  MATRIX_DIAG = 113,
  QUANTIZE = 114,
  MATRIX_SET_DIAG = 115,
  ROUND = 116,
  HARD_SWISH = 117,
  IF = 118,
  WHILE = 119,
  NON_MAX_SUPPRESSION_V4 = 120,
  NON_MAX_SUPPRESSION_V5 = 121,
  SCATTER_ND = 122,
  SELECT_V2 = 123,
  DENSIFY = 124,
  SEGMENT_SUM = 125,
  BATCH_MATMUL = 126,
  PLACEHOLDER_FOR_GREATER_OP_CODES = 127,
  CUMSUM = 128,
  CALL_ONCE = 129,
  BROADCAST_TO = 130,
  RFFT2D = 131,
  CONV_3D = 132,
  IMAG = 133,
  REAL = 134,
  COMPLEX_ABS = 135,
  HASHTABLE = 136,
  HASHTABLE_FIND = 137,
  HASHTABLE_IMPORT = 138,
  HASHTABLE_SIZE = 139,
  REDUCE_ALL = 140,
  CONV_3D_TRANSPOSE = 141,
  VAR_HANDLE = 142,
  READ_VARIABLE = 143,
  ASSIGN_VARIABLE = 144,
  BROADCAST_ARGS = 145,
  RANDOM_STANDARD_NORMAL = 146,
  BUCKETIZE = 147,
  RANDOM_UNIFORM = 148,
  MULTINOMIAL = 149,
  GELU = 150,
  DYNAMIC_UPDATE_SLICE = 151,
  RELU_0_TO_1 = 152,
  UNSORTED_SEGMENT_PROD = 153,
  UNSORTED_SEGMENT_MAX = 154,
  UNSORTED_SEGMENT_SUM = 155,
  ATAN2 = 156,
  UNSORTED_SEGMENT_MIN = 157,
  SIGN = 158,
  BITCAST = 159,
  BITWISE_XOR = 160,
  RIGHT_SHIFT = 161,
  STABLEHLO_LOGISTIC = 162,
  STABLEHLO_ADD = 163,
  STABLEHLO_DIVIDE = 164,
  STABLEHLO_MULTIPLY = 165,
  STABLEHLO_MAXIMUM = 166,
  STABLEHLO_RESHAPE = 167,
  STABLEHLO_CLAMP = 168,
  STABLEHLO_CONCATENATE = 169,
  STABLEHLO_BROADCAST_IN_DIM = 170,
  STABLEHLO_CONVOLUTION = 171,
  STABLEHLO_SLICE = 172,
  STABLEHLO_CUSTOM_CALL = 173,
  STABLEHLO_REDUCE = 174,
  STABLEHLO_ABS = 175,
  STABLEHLO_AND = 176,
  STABLEHLO_COSINE = 177,
  STABLEHLO_EXPONENTIAL = 178,
  STABLEHLO_FLOOR = 179,
  STABLEHLO_LOG = 180,
  STABLEHLO_MINIMUM = 181,
  STABLEHLO_NEGATE = 182,
  STABLEHLO_OR = 183,
  STABLEHLO_POWER = 184,
  STABLEHLO_REMAINDER = 185,
  STABLEHLO_RSQRT = 186,
  STABLEHLO_SELECT = 187,
  STABLEHLO_SUBTRACT = 188,
  STABLEHLO_TANH = 189,
  STABLEHLO_SCATTER = 190,
  STABLEHLO_COMPARE = 191,
  STABLEHLO_CONVERT = 192,
  STABLEHLO_DYNAMIC_SLICE = 193,
  STABLEHLO_DYNAMIC_UPDATE_SLICE = 194,
  STABLEHLO_PAD = 195,
  STABLEHLO_IOTA = 196,
  STABLEHLO_DOT_GENERAL = 197,
  STABLEHLO_REDUCE_WINDOW = 198,
  STABLEHLO_SORT = 199,
  STABLEHLO_WHILE = 200,
  STABLEHLO_GATHER = 201,
  STABLEHLO_TRANSPOSE = 202,
  DILATE = 203,
  STABLEHLO_RNG_BIT_GENERATOR = 204,
  REDUCE_WINDOW = 205,
  STABLEHLO_COMPOSITE = 206,
  STABLEHLO_SHIFT_LEFT = 207,
  STABLEHLO_CBRT = 208,
  MIN = ADD,
  MAX = STABLEHLO_CBRT
};

inline const BuiltinOperator (&EnumValuesBuiltinOperator())[209] {
  static const BuiltinOperator values[] = {
    BuiltinOperator::ADD,
    BuiltinOperator::AVERAGE_POOL_2D,
    BuiltinOperator::CONCATENATION,
    BuiltinOperator::CONV_2D,
    BuiltinOperator::DEPTHWISE_CONV_2D,
    BuiltinOperator::DEPTH_TO_SPACE,
    BuiltinOperator::DEQUANTIZE,
    BuiltinOperator::EMBEDDING_LOOKUP,
    BuiltinOperator::FLOOR,
    BuiltinOperator::FULLY_CONNECTED,
    BuiltinOperator::HASHTABLE_LOOKUP,
    BuiltinOperator::L2_NORMALIZATION,
    BuiltinOperator::L2_POOL_2D,
    BuiltinOperator::LOCAL_RESPONSE_NORMALIZATION,
    BuiltinOperator::LOGISTIC,
    BuiltinOperator::LSH_PROJECTION,
    BuiltinOperator::LSTM,
    BuiltinOperator::MAX_POOL_2D,
    BuiltinOperator::MUL,
    BuiltinOperator::RELU,
    BuiltinOperator::RELU_N1_TO_1,
    BuiltinOperator::RELU6,
    BuiltinOperator::RESHAPE,
    BuiltinOperator::RESIZE_BILINEAR,
    BuiltinOperator::RNN,
    BuiltinOperator::SOFTMAX,
    BuiltinOperator::SPACE_TO_DEPTH,
    BuiltinOperator::SVDF,
    BuiltinOperator::TANH,
    BuiltinOperator::CONCAT_EMBEDDINGS,
    BuiltinOperator::SKIP_GRAM,
    BuiltinOperator::CALL,
    BuiltinOperator::CUSTOM,
    BuiltinOperator::EMBEDDING_LOOKUP_SPARSE,
    BuiltinOperator::PAD,
    BuiltinOperator::UNIDIRECTIONAL_SEQUENCE_RNN,
    BuiltinOperator::GATHER,
    BuiltinOperator::BATCH_TO_SPACE_ND,
    BuiltinOperator::SPACE_TO_BATCH_ND,
    BuiltinOperator::TRANSPOSE,
    BuiltinOperator::MEAN,
    BuiltinOperator::SUB,
    BuiltinOperator::DIV,
    BuiltinOperator::SQUEEZE,
    BuiltinOperator::UNIDIRECTIONAL_SEQUENCE_LSTM,
    BuiltinOperator::STRIDED_SLICE,
    BuiltinOperator::BIDIRECTIONAL_SEQUENCE_RNN,
    BuiltinOperator::EXP,
    BuiltinOperator::TOPK_V2,
    BuiltinOperator::SPLIT,
    BuiltinOperator::LOG_SOFTMAX,
    BuiltinOperator::DELEGATE,
    BuiltinOperator::BIDIRECTIONAL_SEQUENCE_LSTM,
    BuiltinOperator::CAST,
    BuiltinOperator::PRELU,
    BuiltinOperator::MAXIMUM,
    BuiltinOperator::ARGMAX,
    BuiltinOperator::MINIMUM,
    BuiltinOperator::LESS,
    BuiltinOperator::NEG,
    BuiltinOperator::PADV2,
    BuiltinOperator::GREATER,
    BuiltinOperator::GREATER_EQUAL,
    BuiltinOperator::LESS_EQUAL,
    BuiltinOperator::SELECT,
    BuiltinOperator::SLICE,
    BuiltinOperator::SIN,
    BuiltinOperator::TRANSPOSE_CONV,
    BuiltinOperator::SPARSE_TO_DENSE,
    BuiltinOperator::TILE,
    BuiltinOperator::EXPAND_DIMS,
    BuiltinOperator::EQUAL,
    BuiltinOperator::NOT_EQUAL,
    BuiltinOperator::LOG,
    BuiltinOperator::SUM,
    BuiltinOperator::SQRT,
    BuiltinOperator::RSQRT,
    BuiltinOperator::SHAPE,
    BuiltinOperator::POW,
    BuiltinOperator::ARG_MIN,
    BuiltinOperator::FAKE_QUANT,
    BuiltinOperator::REDUCE_PROD,
    BuiltinOperator::REDUCE_MAX,
    BuiltinOperator::PACK,
    BuiltinOperator::LOGICAL_OR,
    BuiltinOperator::ONE_HOT,
    BuiltinOperator::LOGICAL_AND,
    BuiltinOperator::LOGICAL_NOT,
    BuiltinOperator::UNPACK,
    BuiltinOperator::REDUCE_MIN,
    BuiltinOperator::FLOOR_DIV,
    BuiltinOperator::REDUCE_ANY,
    BuiltinOperator::SQUARE,
    BuiltinOperator::ZEROS_LIKE,
    BuiltinOperator::FILL,
    BuiltinOperator::FLOOR_MOD,
    BuiltinOperator::RANGE,
    BuiltinOperator::RESIZE_NEAREST_NEIGHBOR,
    BuiltinOperator::LEAKY_RELU,
    BuiltinOperator::SQUARED_DIFFERENCE,
    BuiltinOperator::MIRROR_PAD,
    BuiltinOperator::ABS,
    BuiltinOperator::SPLIT_V,
    BuiltinOperator::UNIQUE,
    BuiltinOperator::CEIL,
    BuiltinOperator::REVERSE_V2,
    BuiltinOperator::ADD_N,
    BuiltinOperator::GATHER_ND,
    BuiltinOperator::COS,
    BuiltinOperator::WHERE,
    BuiltinOperator::RANK,
    BuiltinOperator::ELU,
    BuiltinOperator::REVERSE_SEQUENCE,
    BuiltinOperator::MATRIX_DIAG,
    BuiltinOperator::QUANTIZE,
    BuiltinOperator::MATRIX_SET_DIAG,
    BuiltinOperator::ROUND,
    BuiltinOperator::HARD_SWISH,
    BuiltinOperator::IF,
    BuiltinOperator::WHILE,
    BuiltinOperator::NON_MAX_SUPPRESSION_V4,
    BuiltinOperator::NON_MAX_SUPPRESSION_V5,
    BuiltinOperator::SCATTER_ND,
    BuiltinOperator::SELECT_V2,
    BuiltinOperator::DENSIFY,
    BuiltinOperator::SEGMENT_SUM,
    BuiltinOperator::BATCH_MATMUL,
    BuiltinOperator::PLACEHOLDER_FOR_GREATER_OP_CODES,
    BuiltinOperator::CUMSUM,
    BuiltinOperator::CALL_ONCE,
    BuiltinOperator::BROADCAST_TO,
    BuiltinOperator::RFFT2D,
    BuiltinOperator::CONV_3D,
    BuiltinOperator::IMAG,
    BuiltinOperator::REAL,
    BuiltinOperator::COMPLEX_ABS,
    BuiltinOperator::HASHTABLE,
    BuiltinOperator::HASHTABLE_FIND,
    BuiltinOperator::HASHTABLE_IMPORT,
    BuiltinOperator::HASHTABLE_SIZE,
    BuiltinOperator::REDUCE_ALL,
    BuiltinOperator::CONV_3D_TRANSPOSE,
    BuiltinOperator::VAR_HANDLE,
    BuiltinOperator::READ_VARIABLE,
    BuiltinOperator::ASSIGN_VARIABLE,
    BuiltinOperator::BROADCAST_ARGS,
    BuiltinOperator::RANDOM_STANDARD_NORMAL,
    BuiltinOperator::BUCKETIZE,
    BuiltinOperator::RANDOM_UNIFORM,
    BuiltinOperator::MULTINOMIAL,
    BuiltinOperator::GELU,
    BuiltinOperator::DYNAMIC_UPDATE_SLICE,
    BuiltinOperator::RELU_0_TO_1,
    BuiltinOperator::UNSORTED_SEGMENT_PROD,
    BuiltinOperator::UNSORTED_SEGMENT_MAX,
    BuiltinOperator::UNSORTED_SEGMENT_SUM,
    BuiltinOperator::ATAN2,
    BuiltinOperator::UNSORTED_SEGMENT_MIN,
    BuiltinOperator::SIGN,
    BuiltinOperator::BITCAST,
    BuiltinOperator::BITWISE_XOR,
    BuiltinOperator::RIGHT_SHIFT,
    BuiltinOperator::STABLEHLO_LOGISTIC,
    BuiltinOperator::STABLEHLO_ADD,
    BuiltinOperator::STABLEHLO_DIVIDE,
    BuiltinOperator::STABLEHLO_MULTIPLY,
    BuiltinOperator::STABLEHLO_MAXIMUM,
    BuiltinOperator::STABLEHLO_RESHAPE,
    BuiltinOperator::STABLEHLO_CLAMP,
    BuiltinOperator::STABLEHLO_CONCATENATE,
    BuiltinOperator::STABLEHLO_BROADCAST_IN_DIM,
    BuiltinOperator::STABLEHLO_CONVOLUTION,
    BuiltinOperator::STABLEHLO_SLICE,
    BuiltinOperator::STABLEHLO_CUSTOM_CALL,
    BuiltinOperator::STABLEHLO_REDUCE,
    BuiltinOperator::STABLEHLO_ABS,
    BuiltinOperator::STABLEHLO_AND,
    BuiltinOperator::STABLEHLO_COSINE,
    BuiltinOperator::STABLEHLO_EXPONENTIAL,
    BuiltinOperator::STABLEHLO_FLOOR,
    BuiltinOperator::STABLEHLO_LOG,
    BuiltinOperator::STABLEHLO_MINIMUM,
    BuiltinOperator::STABLEHLO_NEGATE,
    BuiltinOperator::STABLEHLO_OR,
    BuiltinOperator::STABLEHLO_POWER,
    BuiltinOperator::STABLEHLO_REMAINDER,
    BuiltinOperator::STABLEHLO_RSQRT,
    BuiltinOperator::STABLEHLO_SELECT,
    BuiltinOperator::STABLEHLO_SUBTRACT,
    BuiltinOperator::STABLEHLO_TANH,
    BuiltinOperator::STABLEHLO_SCATTER,
    BuiltinOperator::STABLEHLO_COMPARE,
    BuiltinOperator::STABLEHLO_CONVERT,
    BuiltinOperator::STABLEHLO_DYNAMIC_SLICE,
    BuiltinOperator::STABLEHLO_DYNAMIC_UPDATE_SLICE,
    BuiltinOperator::STABLEHLO_PAD,
    BuiltinOperator::STABLEHLO_IOTA,
    BuiltinOperator::STABLEHLO_DOT_GENERAL,
    BuiltinOperator::STABLEHLO_REDUCE_WINDOW,
    BuiltinOperator::STABLEHLO_SORT,
    BuiltinOperator::STABLEHLO_WHILE,
    BuiltinOperator::STABLEHLO_GATHER,
    BuiltinOperator::STABLEHLO_TRANSPOSE,
    BuiltinOperator::DILATE,
    BuiltinOperator::STABLEHLO_RNG_BIT_GENERATOR,
    BuiltinOperator::REDUCE_WINDOW,
    BuiltinOperator::STABLEHLO_COMPOSITE,
    BuiltinOperator::STABLEHLO_SHIFT_LEFT,
    BuiltinOperator::STABLEHLO_CBRT
  };
  return values;
}

inline const char * const *EnumNamesBuiltinOperator() {
  static const char * const names[210] = {
    "ADD",
    "AVERAGE_POOL_2D",
    "CONCATENATION",
    "CONV_2D",
    "DEPTHWISE_CONV_2D",
    "DEPTH_TO_SPACE",
    "DEQUANTIZE",
    "EMBEDDING_LOOKUP",
    "FLOOR",
    "FULLY_CONNECTED",
    "HASHTABLE_LOOKUP",
    "L2_NORMALIZATION",
    "L2_POOL_2D",
    "LOCAL_RESPONSE_NORMALIZATION",
    "LOGISTIC",
    "LSH_PROJECTION",
    "LSTM",
    "MAX_POOL_2D",
    "MUL",
    "RELU",
    "RELU_N1_TO_1",
    "RELU6",
    "RESHAPE",
    "RESIZE_BILINEAR",
    "RNN",
    "SOFTMAX",
    "SPACE_TO_DEPTH",
    "SVDF",
    "TANH",
    "CONCAT_EMBEDDINGS",
    "SKIP_GRAM",
    "CALL",
    "CUSTOM",
    "EMBEDDING_LOOKUP_SPARSE",
    "PAD",
    "UNIDIRECTIONAL_SEQUENCE_RNN",
    "GATHER",
    "BATCH_TO_SPACE_ND",
    "SPACE_TO_BATCH_ND",
    "TRANSPOSE",
    "MEAN",
    "SUB",
    "DIV",
    "SQUEEZE",
    "UNIDIRECTIONAL_SEQUENCE_LSTM",
    "STRIDED_SLICE",
    "BIDIRECTIONAL_SEQUENCE_RNN",
    "EXP",
    "TOPK_V2",
    "SPLIT",
    "LOG_SOFTMAX",
    "DELEGATE",
    "BIDIRECTIONAL_SEQUENCE_LSTM",
    "CAST",
    "PRELU",
    "MAXIMUM",
    "ARGMAX",
    "MINIMUM",
    "LESS",
    "NEG",
    "PADV2",
    "GREATER",
    "GREATER_EQUAL",
    "LESS_EQUAL",
    "SELECT",
    "SLICE",
    "SIN",
    "TRANSPOSE_CONV",
    "SPARSE_TO_DENSE",
    "TILE",
    "EXPAND_DIMS",
    "EQUAL",
    "NOT_EQUAL",
    "LOG",
    "SUM",
    "SQRT",
    "RSQRT",
    "SHAPE",
    "POW",
    "ARG_MIN",
    "FAKE_QUANT",
    "REDUCE_PROD",
    "REDUCE_MAX",
    "PACK",
    "LOGICAL_OR",
    "ONE_HOT",
    "LOGICAL_AND",
    "LOGICAL_NOT",
    "UNPACK",
    "REDUCE_MIN",
    "FLOOR_DIV",
    "REDUCE_ANY",
    "SQUARE",
    "ZEROS_LIKE",
    "FILL",
    "FLOOR_MOD",
    "RANGE",
    "RESIZE_NEAREST_NEIGHBOR",
    "LEAKY_RELU",
    "SQUARED_DIFFERENCE",
    "MIRROR_PAD",
    "ABS",
    "SPLIT_V",
    "UNIQUE",
    "CEIL",
    "REVERSE_V2",
    "ADD_N",
    "GATHER_ND",
    "COS",
    "WHERE",
    "RANK",
    "ELU",
    "REVERSE_SEQUENCE",
    "MATRIX_DIAG",
    "QUANTIZE",
    "MATRIX_SET_DIAG",
    "ROUND",
    "HARD_SWISH",
    "IF",
    "WHILE",
    "NON_MAX_SUPPRESSION_V4",
    "NON_MAX_SUPPRESSION_V5",
    "SCATTER_ND",
    "SELECT_V2",
    "DENSIFY",
    "SEGMENT_SUM",
    "BATCH_MATMUL",
    "PLACEHOLDER_FOR_GREATER_OP_CODES",
    "CUMSUM",
    "CALL_ONCE",
    "BROADCAST_TO",
    "RFFT2D",
    "CONV_3D",
    "IMAG",
    "REAL",
    "COMPLEX_ABS",
    "HASHTABLE",
    "HASHTABLE_FIND",
    "HASHTABLE_IMPORT",
    "HASHTABLE_SIZE",
    "REDUCE_ALL",
    "CONV_3D_TRANSPOSE",
    "VAR_HANDLE",
    "READ_VARIABLE",
    "ASSIGN_VARIABLE",
    "BROADCAST_ARGS",
    "RANDOM_STANDARD_NORMAL",
    "BUCKETIZE",
    "RANDOM_UNIFORM",
    "MULTINOMIAL",
    "GELU",
    "DYNAMIC_UPDATE_SLICE",
    "RELU_0_TO_1",
    "UNSORTED_SEGMENT_PROD",
    "UNSORTED_SEGMENT_MAX",
    "UNSORTED_SEGMENT_SUM",
    "ATAN2",
    "UNSORTED_SEGMENT_MIN",
    "SIGN",
    "BITCAST",
    "BITWISE_XOR",
    "RIGHT_SHIFT",
    "STABLEHLO_LOGISTIC",
    "STABLEHLO_ADD",
    "STABLEHLO_DIVIDE",
    "STABLEHLO_MULTIPLY",
    "STABLEHLO_MAXIMUM",
    "STABLEHLO_RESHAPE",
    "STABLEHLO_CLAMP",
    "STABLEHLO_CONCATENATE",
    "STABLEHLO_BROADCAST_IN_DIM",
    "STABLEHLO_CONVOLUTION",
    "STABLEHLO_SLICE",
    "STABLEHLO_CUSTOM_CALL",
    "STABLEHLO_REDUCE",
    "STABLEHLO_ABS",
    "STABLEHLO_AND",
    "STABLEHLO_COSINE",
    "STABLEHLO_EXPONENTIAL",
    "STABLEHLO_FLOOR",
    "STABLEHLO_LOG",
    "STABLEHLO_MINIMUM",
    "STABLEHLO_NEGATE",
    "STABLEHLO_OR",
    "STABLEHLO_POWER",
    "STABLEHLO_REMAINDER",
    "STABLEHLO_RSQRT",
    "STABLEHLO_SELECT",
    "STABLEHLO_SUBTRACT",
    "STABLEHLO_TANH",
    "STABLEHLO_SCATTER",
    "STABLEHLO_COMPARE",
    "STABLEHLO_CONVERT",
    "STABLEHLO_DYNAMIC_SLICE",
    "STABLEHLO_DYNAMIC_UPDATE_SLICE",
    "STABLEHLO_PAD",
    "STABLEHLO_IOTA",
    "STABLEHLO_DOT_GENERAL",
    "STABLEHLO_REDUCE_WINDOW",
    "STABLEHLO_SORT",
    "STABLEHLO_WHILE",
    "STABLEHLO_GATHER",
    "STABLEHLO_TRANSPOSE",
    "DILATE",
    "STABLEHLO_RNG_BIT_GENERATOR",
    "REDUCE_WINDOW",
    "STABLEHLO_COMPOSITE",
    "STABLEHLO_SHIFT_LEFT",
    "STABLEHLO_CBRT",
    nullptr
  };
  return names;
}

inline const char *EnumNameBuiltinOperator(BuiltinOperator e) {
  if (::flatbuffers::IsOutRange(e, BuiltinOperator::ADD, BuiltinOperator::STABLEHLO_CBRT)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBuiltinOperator()[index];
}

enum class BuiltinOptions : uint8_t {
  NONE = 0,
  Conv2DOptions = 1,
  DepthwiseConv2DOptions = 2,
  ConcatEmbeddingsOptions = 3,
  LSHProjectionOptions = 4,
  Pool2DOptions = 5,
  SVDFOptions = 6,
  RNNOptions = 7,
  FullyConnectedOptions = 8,
  SoftmaxOptions = 9,
  ConcatenationOptions = 10,
  AddOptions = 11,
  L2NormOptions = 12,
  LocalResponseNormalizationOptions = 13,
  LSTMOptions = 14,
  ResizeBilinearOptions = 15,
  CallOptions = 16,
  ReshapeOptions = 17,
  SkipGramOptions = 18,
  SpaceToDepthOptions = 19,
  EmbeddingLookupSparseOptions = 20,
  MulOptions = 21,
  PadOptions = 22,
  GatherOptions = 23,
  BatchToSpaceNDOptions = 24,
  SpaceToBatchNDOptions = 25,
  TransposeOptions = 26,
  ReducerOptions = 27,
  SubOptions = 28,
  DivOptions = 29,
  SqueezeOptions = 30,
  SequenceRNNOptions = 31,
  StridedSliceOptions = 32,
  ExpOptions = 33,
  TopKV2Options = 34,
  SplitOptions = 35,
  LogSoftmaxOptions = 36,
  CastOptions = 37,
  DequantizeOptions = 38,
  MaximumMinimumOptions = 39,
  ArgMaxOptions = 40,
  LessOptions = 41,
  NegOptions = 42,
  PadV2Options = 43,
  GreaterOptions = 44,
  GreaterEqualOptions = 45,
  LessEqualOptions = 46,
  SelectOptions = 47,
  SliceOptions = 48,
  TransposeConvOptions = 49,
  SparseToDenseOptions = 50,
  TileOptions = 51,
  ExpandDimsOptions = 52,
  EqualOptions = 53,
  NotEqualOptions = 54,
  ShapeOptions = 55,
  PowOptions = 56,
  ArgMinOptions = 57,
  FakeQuantOptions = 58,
  PackOptions = 59,
  LogicalOrOptions = 60,
  OneHotOptions = 61,
  LogicalAndOptions = 62,
  LogicalNotOptions = 63,
  UnpackOptions = 64,
  FloorDivOptions = 65,
  SquareOptions = 66,
  ZerosLikeOptions = 67,
  FillOptions = 68,
  BidirectionalSequenceLSTMOptions = 69,
  BidirectionalSequenceRNNOptions = 70,
  UnidirectionalSequenceLSTMOptions = 71,
  FloorModOptions = 72,
  RangeOptions = 73,
  ResizeNearestNeighborOptions = 74,
  LeakyReluOptions = 75,
  SquaredDifferenceOptions = 76,
  MirrorPadOptions = 77,
  AbsOptions = 78,
  SplitVOptions = 79,
  UniqueOptions = 80,
  ReverseV2Options = 81,
  AddNOptions = 82,
  GatherNdOptions = 83,
  CosOptions = 84,
  WhereOptions = 85,
  RankOptions = 86,
  ReverseSequenceOptions = 87,
  MatrixDiagOptions = 88,
  QuantizeOptions = 89,
  MatrixSetDiagOptions = 90,
  HardSwishOptions = 91,
  IfOptions = 92,
  WhileOptions = 93,
  DepthToSpaceOptions = 94,
  NonMaxSuppressionV4Options = 95,
  NonMaxSuppressionV5Options = 96,
  ScatterNdOptions = 97,
  SelectV2Options = 98,
  DensifyOptions = 99,
  SegmentSumOptions = 100,
  BatchMatMulOptions = 101,
  CumsumOptions = 102,
  CallOnceOptions = 103,
  BroadcastToOptions = 104,
  Rfft2dOptions = 105,
  Conv3DOptions = 106,
  HashtableOptions = 107,
  HashtableFindOptions = 108,
  HashtableImportOptions = 109,
  HashtableSizeOptions = 110,
  VarHandleOptions = 111,
  ReadVariableOptions = 112,
  AssignVariableOptions = 113,
  RandomOptions = 114,
  BucketizeOptions = 115,
  GeluOptions = 116,
  DynamicUpdateSliceOptions = 117,
  UnsortedSegmentProdOptions = 118,
  UnsortedSegmentMaxOptions = 119,
  UnsortedSegmentMinOptions = 120,
  UnsortedSegmentSumOptions = 121,
  ATan2Options = 122,
  SignOptions = 123,
  BitcastOptions = 124,
  BitwiseXorOptions = 125,
  RightShiftOptions = 126,
  MIN = NONE,
  MAX = RightShiftOptions
};

inline const BuiltinOptions (&EnumValuesBuiltinOptions())[127] {
  static const BuiltinOptions values[] = {
    BuiltinOptions::NONE,
    BuiltinOptions::Conv2DOptions,
    BuiltinOptions::DepthwiseConv2DOptions,
    BuiltinOptions::ConcatEmbeddingsOptions,
    BuiltinOptions::LSHProjectionOptions,
    BuiltinOptions::Pool2DOptions,
    BuiltinOptions::SVDFOptions,
    BuiltinOptions::RNNOptions,
    BuiltinOptions::FullyConnectedOptions,
    BuiltinOptions::SoftmaxOptions,
    BuiltinOptions::ConcatenationOptions,
    BuiltinOptions::AddOptions,
    BuiltinOptions::L2NormOptions,
    BuiltinOptions::LocalResponseNormalizationOptions,
    BuiltinOptions::LSTMOptions,
    BuiltinOptions::ResizeBilinearOptions,
    BuiltinOptions::CallOptions,
    BuiltinOptions::ReshapeOptions,
    BuiltinOptions::SkipGramOptions,
    BuiltinOptions::SpaceToDepthOptions,
    BuiltinOptions::EmbeddingLookupSparseOptions,
    BuiltinOptions::MulOptions,
    BuiltinOptions::PadOptions,
    BuiltinOptions::GatherOptions,
    BuiltinOptions::BatchToSpaceNDOptions,
    BuiltinOptions::SpaceToBatchNDOptions,
    BuiltinOptions::TransposeOptions,
    BuiltinOptions::ReducerOptions,
    BuiltinOptions::SubOptions,
    BuiltinOptions::DivOptions,
    BuiltinOptions::SqueezeOptions,
    BuiltinOptions::SequenceRNNOptions,
    BuiltinOptions::StridedSliceOptions,
    BuiltinOptions::ExpOptions,
    BuiltinOptions::TopKV2Options,
    BuiltinOptions::SplitOptions,
    BuiltinOptions::LogSoftmaxOptions,
    BuiltinOptions::CastOptions,
    BuiltinOptions::DequantizeOptions,
    BuiltinOptions::MaximumMinimumOptions,
    BuiltinOptions::ArgMaxOptions,
    BuiltinOptions::LessOptions,
    BuiltinOptions::NegOptions,
    BuiltinOptions::PadV2Options,
    BuiltinOptions::GreaterOptions,
    BuiltinOptions::GreaterEqualOptions,
    BuiltinOptions::LessEqualOptions,
    BuiltinOptions::SelectOptions,
    BuiltinOptions::SliceOptions,
    BuiltinOptions::TransposeConvOptions,
    BuiltinOptions::SparseToDenseOptions,
    BuiltinOptions::TileOptions,
    BuiltinOptions::ExpandDimsOptions,
    BuiltinOptions::EqualOptions,
    BuiltinOptions::NotEqualOptions,
    BuiltinOptions::ShapeOptions,
    BuiltinOptions::PowOptions,
    BuiltinOptions::ArgMinOptions,
    BuiltinOptions::FakeQuantOptions,
    BuiltinOptions::PackOptions,
    BuiltinOptions::LogicalOrOptions,
    BuiltinOptions::OneHotOptions,
    BuiltinOptions::LogicalAndOptions,
    BuiltinOptions::LogicalNotOptions,
    BuiltinOptions::UnpackOptions,
    BuiltinOptions::FloorDivOptions,
    BuiltinOptions::SquareOptions,
    BuiltinOptions::ZerosLikeOptions,
    BuiltinOptions::FillOptions,
    BuiltinOptions::BidirectionalSequenceLSTMOptions,
    BuiltinOptions::BidirectionalSequenceRNNOptions,
    BuiltinOptions::UnidirectionalSequenceLSTMOptions,
    BuiltinOptions::FloorModOptions,
    BuiltinOptions::RangeOptions,
    BuiltinOptions::ResizeNearestNeighborOptions,
    BuiltinOptions::LeakyReluOptions,
    BuiltinOptions::SquaredDifferenceOptions,
    BuiltinOptions::MirrorPadOptions,
    BuiltinOptions::AbsOptions,
    BuiltinOptions::SplitVOptions,
    BuiltinOptions::UniqueOptions,
    BuiltinOptions::ReverseV2Options,
    BuiltinOptions::AddNOptions,
    BuiltinOptions::GatherNdOptions,
    BuiltinOptions::CosOptions,
    BuiltinOptions::WhereOptions,
    BuiltinOptions::RankOptions,
    BuiltinOptions::ReverseSequenceOptions,
    BuiltinOptions::MatrixDiagOptions,
    BuiltinOptions::QuantizeOptions,
    BuiltinOptions::MatrixSetDiagOptions,
    BuiltinOptions::HardSwishOptions,
    BuiltinOptions::IfOptions,
    BuiltinOptions::WhileOptions,
    BuiltinOptions::DepthToSpaceOptions,
    BuiltinOptions::NonMaxSuppressionV4Options,
    BuiltinOptions::NonMaxSuppressionV5Options,
    BuiltinOptions::ScatterNdOptions,
    BuiltinOptions::SelectV2Options,
    BuiltinOptions::DensifyOptions,
    BuiltinOptions::SegmentSumOptions,
    BuiltinOptions::BatchMatMulOptions,
    BuiltinOptions::CumsumOptions,
    BuiltinOptions::CallOnceOptions,
    BuiltinOptions::BroadcastToOptions,
    BuiltinOptions::Rfft2dOptions,
    BuiltinOptions::Conv3DOptions,
    BuiltinOptions::HashtableOptions,
    BuiltinOptions::HashtableFindOptions,
    BuiltinOptions::HashtableImportOptions,
    BuiltinOptions::HashtableSizeOptions,
    BuiltinOptions::VarHandleOptions,
    BuiltinOptions::ReadVariableOptions,
    BuiltinOptions::AssignVariableOptions,
    BuiltinOptions::RandomOptions,
    BuiltinOptions::BucketizeOptions,
    BuiltinOptions::GeluOptions,
    BuiltinOptions::DynamicUpdateSliceOptions,
    BuiltinOptions::UnsortedSegmentProdOptions,
    BuiltinOptions::UnsortedSegmentMaxOptions,
    BuiltinOptions::UnsortedSegmentMinOptions,
    BuiltinOptions::UnsortedSegmentSumOptions,
    BuiltinOptions::ATan2Options,
    BuiltinOptions::SignOptions,
    BuiltinOptions::BitcastOptions,
    BuiltinOptions::BitwiseXorOptions,
    BuiltinOptions::RightShiftOptions
  };
  return values;
}

inline const char * const *EnumNamesBuiltinOptions() {
  static const char * const names[128] = {
    "NONE",
    "Conv2DOptions",
    "DepthwiseConv2DOptions",
    "ConcatEmbeddingsOptions",
    "LSHProjectionOptions",
    "Pool2DOptions",
    "SVDFOptions",
    "RNNOptions",
    "FullyConnectedOptions",
    "SoftmaxOptions",
    "ConcatenationOptions",
    "AddOptions",
    "L2NormOptions",
    "LocalResponseNormalizationOptions",
    "LSTMOptions",
    "ResizeBilinearOptions",
    "CallOptions",
    "ReshapeOptions",
    "SkipGramOptions",
    "SpaceToDepthOptions",
    "EmbeddingLookupSparseOptions",
    "MulOptions",
    "PadOptions",
    "GatherOptions",
    "BatchToSpaceNDOptions",
    "SpaceToBatchNDOptions",
    "TransposeOptions",
    "ReducerOptions",
    "SubOptions",
    "DivOptions",
    "SqueezeOptions",
    "SequenceRNNOptions",
    "StridedSliceOptions",
    "ExpOptions",
    "TopKV2Options",
    "SplitOptions",
    "LogSoftmaxOptions",
    "CastOptions",
    "DequantizeOptions",
    "MaximumMinimumOptions",
    "ArgMaxOptions",
    "LessOptions",
    "NegOptions",
    "PadV2Options",
    "GreaterOptions",
    "GreaterEqualOptions",
    "LessEqualOptions",
    "SelectOptions",
    "SliceOptions",
    "TransposeConvOptions",
    "SparseToDenseOptions",
    "TileOptions",
    "ExpandDimsOptions",
    "EqualOptions",
    "NotEqualOptions",
    "ShapeOptions",
    "PowOptions",
    "ArgMinOptions",
    "FakeQuantOptions",
    "PackOptions",
    "LogicalOrOptions",
    "OneHotOptions",
    "LogicalAndOptions",
    "LogicalNotOptions",
    "UnpackOptions",
    "FloorDivOptions",
    "SquareOptions",
    "ZerosLikeOptions",
    "FillOptions",
    "BidirectionalSequenceLSTMOptions",
    "BidirectionalSequenceRNNOptions",
    "UnidirectionalSequenceLSTMOptions",
    "FloorModOptions",
    "RangeOptions",
    "ResizeNearestNeighborOptions",
    "LeakyReluOptions",
    "SquaredDifferenceOptions",
    "MirrorPadOptions",
    "AbsOptions",
    "SplitVOptions",
    "UniqueOptions",
    "ReverseV2Options",
    "AddNOptions",
    "GatherNdOptions",
    "CosOptions",
    "WhereOptions",
    "RankOptions",
    "ReverseSequenceOptions",
    "MatrixDiagOptions",
    "QuantizeOptions",
    "MatrixSetDiagOptions",
    "HardSwishOptions",
    "IfOptions",
    "WhileOptions",
    "DepthToSpaceOptions",
    "NonMaxSuppressionV4Options",
    "NonMaxSuppressionV5Options",
    "ScatterNdOptions",
    "SelectV2Options",
    "DensifyOptions",
    "SegmentSumOptions",
    "BatchMatMulOptions",
    "CumsumOptions",
    "CallOnceOptions",
    "BroadcastToOptions",
    "Rfft2dOptions",
    "Conv3DOptions",
    "HashtableOptions",
    "HashtableFindOptions",
    "HashtableImportOptions",
    "HashtableSizeOptions",
    "VarHandleOptions",
    "ReadVariableOptions",
    "AssignVariableOptions",
    "RandomOptions",
    "BucketizeOptions",
    "GeluOptions",
    "DynamicUpdateSliceOptions",
    "UnsortedSegmentProdOptions",
    "UnsortedSegmentMaxOptions",
    "UnsortedSegmentMinOptions",
    "UnsortedSegmentSumOptions",
    "ATan2Options",
    "SignOptions",
    "BitcastOptions",
    "BitwiseXorOptions",
    "RightShiftOptions",
    nullptr
  };
  return names;
}

inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
  if (::flatbuffers::IsOutRange(e, BuiltinOptions::NONE, BuiltinOptions::RightShiftOptions)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBuiltinOptions()[index];
}

template<typename T> struct BuiltinOptionsTraits {
  static const BuiltinOptions enum_value = BuiltinOptions::NONE;
};

template<> struct BuiltinOptionsTraits<tflite::Conv2DOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::Conv2DOptions;
};

template<> struct BuiltinOptionsTraits<tflite::DepthwiseConv2DOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DepthwiseConv2DOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ConcatEmbeddingsOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ConcatEmbeddingsOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LSHProjectionOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LSHProjectionOptions;
};

template<> struct BuiltinOptionsTraits<tflite::Pool2DOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::Pool2DOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SVDFOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SVDFOptions;
};

template<> struct BuiltinOptionsTraits<tflite::RNNOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::RNNOptions;
};

template<> struct BuiltinOptionsTraits<tflite::FullyConnectedOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::FullyConnectedOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SoftmaxOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SoftmaxOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ConcatenationOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ConcatenationOptions;
};

template<> struct BuiltinOptionsTraits<tflite::AddOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::AddOptions;
};

template<> struct BuiltinOptionsTraits<tflite::L2NormOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::L2NormOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LocalResponseNormalizationOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LocalResponseNormalizationOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LSTMOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LSTMOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ResizeBilinearOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ResizeBilinearOptions;
};

template<> struct BuiltinOptionsTraits<tflite::CallOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::CallOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ReshapeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ReshapeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SkipGramOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SkipGramOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SpaceToDepthOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SpaceToDepthOptions;
};

template<> struct BuiltinOptionsTraits<tflite::EmbeddingLookupSparseOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::EmbeddingLookupSparseOptions;
};

template<> struct BuiltinOptionsTraits<tflite::MulOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::MulOptions;
};

template<> struct BuiltinOptionsTraits<tflite::PadOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::PadOptions;
};

template<> struct BuiltinOptionsTraits<tflite::GatherOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::GatherOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BatchToSpaceNDOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BatchToSpaceNDOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SpaceToBatchNDOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SpaceToBatchNDOptions;
};

template<> struct BuiltinOptionsTraits<tflite::TransposeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::TransposeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ReducerOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ReducerOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SubOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SubOptions;
};

template<> struct BuiltinOptionsTraits<tflite::DivOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DivOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SqueezeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SqueezeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SequenceRNNOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SequenceRNNOptions;
};

template<> struct BuiltinOptionsTraits<tflite::StridedSliceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::StridedSliceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ExpOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ExpOptions;
};

template<> struct BuiltinOptionsTraits<tflite::TopKV2Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::TopKV2Options;
};

template<> struct BuiltinOptionsTraits<tflite::SplitOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SplitOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LogSoftmaxOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LogSoftmaxOptions;
};

template<> struct BuiltinOptionsTraits<tflite::CastOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::CastOptions;
};

template<> struct BuiltinOptionsTraits<tflite::DequantizeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DequantizeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::MaximumMinimumOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::MaximumMinimumOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ArgMaxOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ArgMaxOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LessOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LessOptions;
};

template<> struct BuiltinOptionsTraits<tflite::NegOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::NegOptions;
};

template<> struct BuiltinOptionsTraits<tflite::PadV2Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::PadV2Options;
};

template<> struct BuiltinOptionsTraits<tflite::GreaterOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::GreaterOptions;
};

template<> struct BuiltinOptionsTraits<tflite::GreaterEqualOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::GreaterEqualOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LessEqualOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LessEqualOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SelectOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SelectOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SliceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SliceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::TransposeConvOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::TransposeConvOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SparseToDenseOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SparseToDenseOptions;
};

template<> struct BuiltinOptionsTraits<tflite::TileOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::TileOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ExpandDimsOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ExpandDimsOptions;
};

template<> struct BuiltinOptionsTraits<tflite::EqualOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::EqualOptions;
};

template<> struct BuiltinOptionsTraits<tflite::NotEqualOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::NotEqualOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ShapeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ShapeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::PowOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::PowOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ArgMinOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ArgMinOptions;
};

template<> struct BuiltinOptionsTraits<tflite::FakeQuantOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::FakeQuantOptions;
};

template<> struct BuiltinOptionsTraits<tflite::PackOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::PackOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LogicalOrOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LogicalOrOptions;
};

template<> struct BuiltinOptionsTraits<tflite::OneHotOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::OneHotOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LogicalAndOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LogicalAndOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LogicalNotOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LogicalNotOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnpackOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnpackOptions;
};

template<> struct BuiltinOptionsTraits<tflite::FloorDivOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::FloorDivOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SquareOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SquareOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ZerosLikeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ZerosLikeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::FillOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::FillOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceLSTMOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BidirectionalSequenceLSTMOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceRNNOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BidirectionalSequenceRNNOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnidirectionalSequenceLSTMOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnidirectionalSequenceLSTMOptions;
};

template<> struct BuiltinOptionsTraits<tflite::FloorModOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::FloorModOptions;
};

template<> struct BuiltinOptionsTraits<tflite::RangeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::RangeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ResizeNearestNeighborOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ResizeNearestNeighborOptions;
};

template<> struct BuiltinOptionsTraits<tflite::LeakyReluOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::LeakyReluOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SquaredDifferenceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SquaredDifferenceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::MirrorPadOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::MirrorPadOptions;
};

template<> struct BuiltinOptionsTraits<tflite::AbsOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::AbsOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SplitVOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SplitVOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UniqueOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UniqueOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ReverseV2Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::ReverseV2Options;
};

template<> struct BuiltinOptionsTraits<tflite::AddNOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::AddNOptions;
};

template<> struct BuiltinOptionsTraits<tflite::GatherNdOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::GatherNdOptions;
};

template<> struct BuiltinOptionsTraits<tflite::CosOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::CosOptions;
};

template<> struct BuiltinOptionsTraits<tflite::WhereOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::WhereOptions;
};

template<> struct BuiltinOptionsTraits<tflite::RankOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::RankOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ReverseSequenceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ReverseSequenceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::MatrixDiagOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::MatrixDiagOptions;
};

template<> struct BuiltinOptionsTraits<tflite::QuantizeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::QuantizeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::MatrixSetDiagOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::MatrixSetDiagOptions;
};

template<> struct BuiltinOptionsTraits<tflite::HardSwishOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::HardSwishOptions;
};

template<> struct BuiltinOptionsTraits<tflite::IfOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::IfOptions;
};

template<> struct BuiltinOptionsTraits<tflite::WhileOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::WhileOptions;
};

template<> struct BuiltinOptionsTraits<tflite::DepthToSpaceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DepthToSpaceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV4Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::NonMaxSuppressionV4Options;
};

template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV5Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::NonMaxSuppressionV5Options;
};

template<> struct BuiltinOptionsTraits<tflite::ScatterNdOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ScatterNdOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SelectV2Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::SelectV2Options;
};

template<> struct BuiltinOptionsTraits<tflite::DensifyOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DensifyOptions;
};

template<> struct BuiltinOptionsTraits<tflite::SegmentSumOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SegmentSumOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BatchMatMulOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BatchMatMulOptions;
};

template<> struct BuiltinOptionsTraits<tflite::CumsumOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::CumsumOptions;
};

template<> struct BuiltinOptionsTraits<tflite::CallOnceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::CallOnceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BroadcastToOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BroadcastToOptions;
};

template<> struct BuiltinOptionsTraits<tflite::Rfft2dOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::Rfft2dOptions;
};

template<> struct BuiltinOptionsTraits<tflite::Conv3DOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::Conv3DOptions;
};

template<> struct BuiltinOptionsTraits<tflite::HashtableOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::HashtableOptions;
};

template<> struct BuiltinOptionsTraits<tflite::HashtableFindOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::HashtableFindOptions;
};

template<> struct BuiltinOptionsTraits<tflite::HashtableImportOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::HashtableImportOptions;
};

template<> struct BuiltinOptionsTraits<tflite::HashtableSizeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::HashtableSizeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::VarHandleOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::VarHandleOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ReadVariableOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::ReadVariableOptions;
};

template<> struct BuiltinOptionsTraits<tflite::AssignVariableOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::AssignVariableOptions;
};

template<> struct BuiltinOptionsTraits<tflite::RandomOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::RandomOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BucketizeOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BucketizeOptions;
};

template<> struct BuiltinOptionsTraits<tflite::GeluOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::GeluOptions;
};

template<> struct BuiltinOptionsTraits<tflite::DynamicUpdateSliceOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::DynamicUpdateSliceOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentProdOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnsortedSegmentProdOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMaxOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnsortedSegmentMaxOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMinOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnsortedSegmentMinOptions;
};

template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentSumOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::UnsortedSegmentSumOptions;
};

template<> struct BuiltinOptionsTraits<tflite::ATan2Options> {
  static const BuiltinOptions enum_value = BuiltinOptions::ATan2Options;
};

template<> struct BuiltinOptionsTraits<tflite::SignOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::SignOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BitcastOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BitcastOptions;
};

template<> struct BuiltinOptionsTraits<tflite::BitwiseXorOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::BitwiseXorOptions;
};

template<> struct BuiltinOptionsTraits<tflite::RightShiftOptions> {
  static const BuiltinOptions enum_value = BuiltinOptions::RightShiftOptions;
};

bool VerifyBuiltinOptions(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<BuiltinOptions> *types);

enum class BuiltinOptions2 : uint8_t {
  NONE = 0,
  StablehloConcatenateOptions = 1,
  StablehloBroadcastInDimOptions = 2,
  StablehloSliceOptions = 3,
  StablehloConvolutionOptions = 4,
  StablehloCustomCallOptions = 5,
  StablehloReduceOptions = 6,
  StablehloScatterOptions = 7,
  StablehloCompareOptions = 8,
  StablehloDynamicSliceOptions = 9,
  StablehloPadOptions = 10,
  StablehloIotaOptions = 11,
  StablehloDotGeneralOptions = 12,
  StablehloReduceWindowOptions = 13,
  StablehloSortOptions = 14,
  StablehloWhileOptions = 15,
  StablehloGatherOptions = 16,
  StablehloTransposeOptions = 17,
  DilateOptions = 18,
  StablehloRngBitGeneratorOptions = 19,
  ReduceWindowOptions = 20,
  StableHLOCompositeOptions = 21,
  StablehloShiftLeftOptions = 22,
  MIN = NONE,
  MAX = StablehloShiftLeftOptions
};

inline const BuiltinOptions2 (&EnumValuesBuiltinOptions2())[23] {
  static const BuiltinOptions2 values[] = {
    BuiltinOptions2::NONE,
    BuiltinOptions2::StablehloConcatenateOptions,
    BuiltinOptions2::StablehloBroadcastInDimOptions,
    BuiltinOptions2::StablehloSliceOptions,
    BuiltinOptions2::StablehloConvolutionOptions,
    BuiltinOptions2::StablehloCustomCallOptions,
    BuiltinOptions2::StablehloReduceOptions,
    BuiltinOptions2::StablehloScatterOptions,
    BuiltinOptions2::StablehloCompareOptions,
    BuiltinOptions2::StablehloDynamicSliceOptions,
    BuiltinOptions2::StablehloPadOptions,
    BuiltinOptions2::StablehloIotaOptions,
    BuiltinOptions2::StablehloDotGeneralOptions,
    BuiltinOptions2::StablehloReduceWindowOptions,
    BuiltinOptions2::StablehloSortOptions,
    BuiltinOptions2::StablehloWhileOptions,
    BuiltinOptions2::StablehloGatherOptions,
    BuiltinOptions2::StablehloTransposeOptions,
    BuiltinOptions2::DilateOptions,
    BuiltinOptions2::StablehloRngBitGeneratorOptions,
    BuiltinOptions2::ReduceWindowOptions,
    BuiltinOptions2::StableHLOCompositeOptions,
    BuiltinOptions2::StablehloShiftLeftOptions
  };
  return values;
}

inline const char * const *EnumNamesBuiltinOptions2() {
  static const char * const names[24] = {
    "NONE",
    "StablehloConcatenateOptions",
    "StablehloBroadcastInDimOptions",
    "StablehloSliceOptions",
    "StablehloConvolutionOptions",
    "StablehloCustomCallOptions",
    "StablehloReduceOptions",
    "StablehloScatterOptions",
    "StablehloCompareOptions",
    "StablehloDynamicSliceOptions",
    "StablehloPadOptions",
    "StablehloIotaOptions",
    "StablehloDotGeneralOptions",
    "StablehloReduceWindowOptions",
    "StablehloSortOptions",
    "StablehloWhileOptions",
    "StablehloGatherOptions",
    "StablehloTransposeOptions",
    "DilateOptions",
    "StablehloRngBitGeneratorOptions",
    "ReduceWindowOptions",
    "StableHLOCompositeOptions",
    "StablehloShiftLeftOptions",
    nullptr
  };
  return names;
}

inline const char *EnumNameBuiltinOptions2(BuiltinOptions2 e) {
  if (::flatbuffers::IsOutRange(e, BuiltinOptions2::NONE, BuiltinOptions2::StablehloShiftLeftOptions)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBuiltinOptions2()[index];
}

template<typename T> struct BuiltinOptions2Traits {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::NONE;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloConcatenateOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloConcatenateOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloBroadcastInDimOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloBroadcastInDimOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloSliceOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloSliceOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloConvolutionOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloConvolutionOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloCustomCallOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloCustomCallOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloReduceOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloReduceOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloScatterOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloScatterOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloCompareOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloCompareOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloDynamicSliceOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloDynamicSliceOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloPadOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloPadOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloIotaOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloIotaOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloDotGeneralOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloDotGeneralOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloReduceWindowOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloReduceWindowOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloSortOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloSortOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloWhileOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloWhileOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloGatherOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloGatherOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloTransposeOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloTransposeOptions;
};

template<> struct BuiltinOptions2Traits<tflite::DilateOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::DilateOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloRngBitGeneratorOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloRngBitGeneratorOptions;
};

template<> struct BuiltinOptions2Traits<tflite::ReduceWindowOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::ReduceWindowOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StableHLOCompositeOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StableHLOCompositeOptions;
};

template<> struct BuiltinOptions2Traits<tflite::StablehloShiftLeftOptions> {
  static const BuiltinOptions2 enum_value = BuiltinOptions2::StablehloShiftLeftOptions;
};

bool VerifyBuiltinOptions2(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type);
bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<BuiltinOptions2> *types);

enum class StablehloPrecisionConfig : uint32_t {
  DEFAULT = 0,
  HIGH = 1,
  HIGHEST = 2,
  MIN = DEFAULT,
  MAX = HIGHEST
};

inline const StablehloPrecisionConfig (&EnumValuesStablehloPrecisionConfig())[3] {
  static const StablehloPrecisionConfig values[] = {
    StablehloPrecisionConfig::DEFAULT,
    StablehloPrecisionConfig::HIGH,
    StablehloPrecisionConfig::HIGHEST
  };
  return values;
}

inline const char * const *EnumNamesStablehloPrecisionConfig() {
  static const char * const names[4] = {
    "DEFAULT",
    "HIGH",
    "HIGHEST",
    nullptr
  };
  return names;
}

inline const char *EnumNameStablehloPrecisionConfig(StablehloPrecisionConfig e) {
  if (::flatbuffers::IsOutRange(e, StablehloPrecisionConfig::DEFAULT, StablehloPrecisionConfig::HIGHEST)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStablehloPrecisionConfig()[index];
}

enum class StablehloComparisonDirection : uint32_t {
  STABLEHLO_COMPARISON_DIRECTION_EQ = 0,
  STABLEHLO_COMPARISON_DIRECTION_NE = 1,
  STABLEHLO_COMPARISON_DIRECTION_GE = 2,
  STABLEHLO_COMPARISON_DIRECTION_GT = 3,
  STABLEHLO_COMPARISON_DIRECTION_LE = 4,
  STABLEHLO_COMPARISON_DIRECTION_LT = 5,
  MIN = STABLEHLO_COMPARISON_DIRECTION_EQ,
  MAX = STABLEHLO_COMPARISON_DIRECTION_LT
};

inline const StablehloComparisonDirection (&EnumValuesStablehloComparisonDirection())[6] {
  static const StablehloComparisonDirection values[] = {
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_EQ,
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_NE,
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_GE,
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_GT,
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_LE,
    StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_LT
  };
  return values;
}

inline const char * const *EnumNamesStablehloComparisonDirection() {
  static const char * const names[7] = {
    "STABLEHLO_COMPARISON_DIRECTION_EQ",
    "STABLEHLO_COMPARISON_DIRECTION_NE",
    "STABLEHLO_COMPARISON_DIRECTION_GE",
    "STABLEHLO_COMPARISON_DIRECTION_GT",
    "STABLEHLO_COMPARISON_DIRECTION_LE",
    "STABLEHLO_COMPARISON_DIRECTION_LT",
    nullptr
  };
  return names;
}

inline const char *EnumNameStablehloComparisonDirection(StablehloComparisonDirection e) {
  if (::flatbuffers::IsOutRange(e, StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_EQ, StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_LT)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStablehloComparisonDirection()[index];
}

enum class StablehloComparisonType : uint32_t {
  STABLEHLO_COMPARISON_TYPE_NOTYPE = 0,
  STABLEHLO_COMPARISON_TYPE_FLOAT = 1,
  STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER = 2,
  STABLEHLO_COMPARISON_TYPE_SIGNED = 3,
  STABLEHLO_COMPARISON_TYPE_UNSIGNED = 4,
  MIN = STABLEHLO_COMPARISON_TYPE_NOTYPE,
  MAX = STABLEHLO_COMPARISON_TYPE_UNSIGNED
};

inline const StablehloComparisonType (&EnumValuesStablehloComparisonType())[5] {
  static const StablehloComparisonType values[] = {
    StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_NOTYPE,
    StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_FLOAT,
    StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER,
    StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_SIGNED,
    StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_UNSIGNED
  };
  return values;
}

inline const char * const *EnumNamesStablehloComparisonType() {
  static const char * const names[6] = {
    "STABLEHLO_COMPARISON_TYPE_NOTYPE",
    "STABLEHLO_COMPARISON_TYPE_FLOAT",
    "STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER",
    "STABLEHLO_COMPARISON_TYPE_SIGNED",
    "STABLEHLO_COMPARISON_TYPE_UNSIGNED",
    nullptr
  };
  return names;
}

inline const char *EnumNameStablehloComparisonType(StablehloComparisonType e) {
  if (::flatbuffers::IsOutRange(e, StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_NOTYPE, StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_UNSIGNED)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStablehloComparisonType()[index];
}

enum class RngAlgorithm : int8_t {
  DEFAULT = 0,
  PHILOX = 1,
  THREEFRY = 2,
  MIN = DEFAULT,
  MAX = THREEFRY
};

inline const RngAlgorithm (&EnumValuesRngAlgorithm())[3] {
  static const RngAlgorithm values[] = {
    RngAlgorithm::DEFAULT,
    RngAlgorithm::PHILOX,
    RngAlgorithm::THREEFRY
  };
  return values;
}

inline const char * const *EnumNamesRngAlgorithm() {
  static const char * const names[4] = {
    "DEFAULT",
    "PHILOX",
    "THREEFRY",
    nullptr
  };
  return names;
}

inline const char *EnumNameRngAlgorithm(RngAlgorithm e) {
  if (::flatbuffers::IsOutRange(e, RngAlgorithm::DEFAULT, RngAlgorithm::THREEFRY)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesRngAlgorithm()[index];
}

enum class Padding : int8_t {
  SAME = 0,
  VALID = 1,
  MIN = SAME,
  MAX = VALID
};

inline const Padding (&EnumValuesPadding())[2] {
  static const Padding values[] = {
    Padding::SAME,
    Padding::VALID
  };
  return values;
}

inline const char * const *EnumNamesPadding() {
  static const char * const names[3] = {
    "SAME",
    "VALID",
    nullptr
  };
  return names;
}

inline const char *EnumNamePadding(Padding e) {
  if (::flatbuffers::IsOutRange(e, Padding::SAME, Padding::VALID)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesPadding()[index];
}

enum class ActivationFunctionType : int8_t {
  NONE = 0,
  RELU = 1,
  RELU_N1_TO_1 = 2,
  RELU6 = 3,
  TANH = 4,
  SIGN_BIT = 5,
  MIN = NONE,
  MAX = SIGN_BIT
};

inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6] {
  static const ActivationFunctionType values[] = {
    ActivationFunctionType::NONE,
    ActivationFunctionType::RELU,
    ActivationFunctionType::RELU_N1_TO_1,
    ActivationFunctionType::RELU6,
    ActivationFunctionType::TANH,
    ActivationFunctionType::SIGN_BIT
  };
  return values;
}

inline const char * const *EnumNamesActivationFunctionType() {
  static const char * const names[7] = {
    "NONE",
    "RELU",
    "RELU_N1_TO_1",
    "RELU6",
    "TANH",
    "SIGN_BIT",
    nullptr
  };
  return names;
}

inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) {
  if (::flatbuffers::IsOutRange(e, ActivationFunctionType::NONE, ActivationFunctionType::SIGN_BIT)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesActivationFunctionType()[index];
}

enum class LSHProjectionType : int8_t {
  UNKNOWN = 0,
  SPARSE = 1,
  DENSE = 2,
  MIN = UNKNOWN,
  MAX = DENSE
};

inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3] {
  static const LSHProjectionType values[] = {
    LSHProjectionType::UNKNOWN,
    LSHProjectionType::SPARSE,
    LSHProjectionType::DENSE
  };
  return values;
}

inline const char * const *EnumNamesLSHProjectionType() {
  static const char * const names[4] = {
    "UNKNOWN",
    "SPARSE",
    "DENSE",
    nullptr
  };
  return names;
}

inline const char *EnumNameLSHProjectionType(LSHProjectionType e) {
  if (::flatbuffers::IsOutRange(e, LSHProjectionType::UNKNOWN, LSHProjectionType::DENSE)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesLSHProjectionType()[index];
}

enum class FullyConnectedOptionsWeightsFormat : int8_t {
  DEFAULT = 0,
  SHUFFLED4x16INT8 = 1,
  MIN = DEFAULT,
  MAX = SHUFFLED4x16INT8
};

inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2] {
  static const FullyConnectedOptionsWeightsFormat values[] = {
    FullyConnectedOptionsWeightsFormat::DEFAULT,
    FullyConnectedOptionsWeightsFormat::SHUFFLED4x16INT8
  };
  return values;
}

inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() {
  static const char * const names[3] = {
    "DEFAULT",
    "SHUFFLED4x16INT8",
    nullptr
  };
  return names;
}

inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) {
  if (::flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat::DEFAULT, FullyConnectedOptionsWeightsFormat::SHUFFLED4x16INT8)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
}

enum class LSTMKernelType : int8_t {
  FULL = 0,
  BASIC = 1,
  MIN = FULL,
  MAX = BASIC
};

inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2] {
  static const LSTMKernelType values[] = {
    LSTMKernelType::FULL,
    LSTMKernelType::BASIC
  };
  return values;
}

inline const char * const *EnumNamesLSTMKernelType() {
  static const char * const names[3] = {
    "FULL",
    "BASIC",
    nullptr
  };
  return names;
}

inline const char *EnumNameLSTMKernelType(LSTMKernelType e) {
  if (::flatbuffers::IsOutRange(e, LSTMKernelType::FULL, LSTMKernelType::BASIC)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesLSTMKernelType()[index];
}

enum class CombinerType : int8_t {
  SUM = 0,
  MEAN = 1,
  SQRTN = 2,
  MIN = SUM,
  MAX = SQRTN
};

inline const CombinerType (&EnumValuesCombinerType())[3] {
  static const CombinerType values[] = {
    CombinerType::SUM,
    CombinerType::MEAN,
    CombinerType::SQRTN
  };
  return values;
}

inline const char * const *EnumNamesCombinerType() {
  static const char * const names[4] = {
    "SUM",
    "MEAN",
    "SQRTN",
    nullptr
  };
  return names;
}

inline const char *EnumNameCombinerType(CombinerType e) {
  if (::flatbuffers::IsOutRange(e, CombinerType::SUM, CombinerType::SQRTN)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCombinerType()[index];
}

enum class MirrorPadMode : int8_t {
  REFLECT = 0,
  SYMMETRIC = 1,
  MIN = REFLECT,
  MAX = SYMMETRIC
};

inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2] {
  static const MirrorPadMode values[] = {
    MirrorPadMode::REFLECT,
    MirrorPadMode::SYMMETRIC
  };
  return values;
}

inline const char * const *EnumNamesMirrorPadMode() {
  static const char * const names[3] = {
    "REFLECT",
    "SYMMETRIC",
    nullptr
  };
  return names;
}

inline const char *EnumNameMirrorPadMode(MirrorPadMode e) {
  if (::flatbuffers::IsOutRange(e, MirrorPadMode::REFLECT, MirrorPadMode::SYMMETRIC)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMirrorPadMode()[index];
}

enum class ReduceWindowFunction : int32_t {
  UNSUPPORTED = 0,
  ADD = 1,
  MUL = 2,
  MINIMUM = 3,
  MAXIMUM = 4,
  ALL = 5,
  ANY = 6,
  MIN = UNSUPPORTED,
  MAX = ANY
};

inline const ReduceWindowFunction (&EnumValuesReduceWindowFunction())[7] {
  static const ReduceWindowFunction values[] = {
    ReduceWindowFunction::UNSUPPORTED,
    ReduceWindowFunction::ADD,
    ReduceWindowFunction::MUL,
    ReduceWindowFunction::MINIMUM,
    ReduceWindowFunction::MAXIMUM,
    ReduceWindowFunction::ALL,
    ReduceWindowFunction::ANY
  };
  return values;
}

inline const char * const *EnumNamesReduceWindowFunction() {
  static const char * const names[8] = {
    "UNSUPPORTED",
    "ADD",
    "MUL",
    "MINIMUM",
    "MAXIMUM",
    "ALL",
    "ANY",
    nullptr
  };
  return names;
}

inline const char *EnumNameReduceWindowFunction(ReduceWindowFunction e) {
  if (::flatbuffers::IsOutRange(e, ReduceWindowFunction::UNSUPPORTED, ReduceWindowFunction::ANY)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesReduceWindowFunction()[index];
}

enum class CustomOptionsFormat : int8_t {
  FLEXBUFFERS = 0,
  MIN = FLEXBUFFERS,
  MAX = FLEXBUFFERS
};

inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] {
  static const CustomOptionsFormat values[] = {
    CustomOptionsFormat::FLEXBUFFERS
  };
  return values;
}

inline const char * const *EnumNamesCustomOptionsFormat() {
  static const char * const names[2] = {
    "FLEXBUFFERS",
    nullptr
  };
  return names;
}

inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) {
  if (::flatbuffers::IsOutRange(e, CustomOptionsFormat::FLEXBUFFERS, CustomOptionsFormat::FLEXBUFFERS)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCustomOptionsFormat()[index];
}

struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CustomQuantizationBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CustomQuantizationTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CUSTOM = 4
  };
  const ::flatbuffers::Vector<uint8_t> *custom() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_custom() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CUSTOM) &&
           verifier.VerifyVector(custom()) &&
           verifier.EndTable();
  }
};

struct CustomQuantizationBuilder {
  typedef CustomQuantization Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_custom(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom) {
    fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
  }
  explicit CustomQuantizationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CustomQuantization> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CustomQuantization>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom = 0) {
  CustomQuantizationBuilder builder_(_fbb);
  builder_.add_custom(custom);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *custom = nullptr) {
  if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16); }
  auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
  return tflite::CreateCustomQuantization(
      _fbb,
      custom__);
}

struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef QuantizationParametersBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return QuantizationParametersTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MIN = 4,
    VT_MAX = 6,
    VT_SCALE = 8,
    VT_ZERO_POINT = 10,
    VT_DETAILS_TYPE = 12,
    VT_DETAILS = 14,
    VT_QUANTIZED_DIMENSION = 16
  };
  const ::flatbuffers::Vector<float> *min() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_MIN);
  }
  ::flatbuffers::Vector<float> *mutable_min() {
    return GetPointer<::flatbuffers::Vector<float> *>(VT_MIN);
  }
  const ::flatbuffers::Vector<float> *max() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_MAX);
  }
  ::flatbuffers::Vector<float> *mutable_max() {
    return GetPointer<::flatbuffers::Vector<float> *>(VT_MAX);
  }
  const ::flatbuffers::Vector<float> *scale() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_SCALE);
  }
  ::flatbuffers::Vector<float> *mutable_scale() {
    return GetPointer<::flatbuffers::Vector<float> *>(VT_SCALE);
  }
  const ::flatbuffers::Vector<int64_t> *zero_point() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
  }
  ::flatbuffers::Vector<int64_t> *mutable_zero_point() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
  }
  tflite::QuantizationDetails details_type() const {
    return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
  }
  const void *details() const {
    return GetPointer<const void *>(VT_DETAILS);
  }
  template<typename T> const T *details_as() const;
  const tflite::CustomQuantization *details_as_CustomQuantization() const {
    return details_type() == tflite::QuantizationDetails::CustomQuantization ? static_cast<const tflite::CustomQuantization *>(details()) : nullptr;
  }
  void *mutable_details() {
    return GetPointer<void *>(VT_DETAILS);
  }
  int32_t quantized_dimension() const {
    return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0);
  }
  bool mutate_quantized_dimension(int32_t _quantized_dimension = 0) {
    return SetField<int32_t>(VT_QUANTIZED_DIMENSION, _quantized_dimension, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_MIN) &&
           verifier.VerifyVector(min()) &&
           VerifyOffset(verifier, VT_MAX) &&
           verifier.VerifyVector(max()) &&
           VerifyOffset(verifier, VT_SCALE) &&
           verifier.VerifyVector(scale()) &&
           VerifyOffset(verifier, VT_ZERO_POINT) &&
           verifier.VerifyVector(zero_point()) &&
           VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE, 1) &&
           VerifyOffset(verifier, VT_DETAILS) &&
           VerifyQuantizationDetails(verifier, details(), details_type()) &&
           VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION, 4) &&
           verifier.EndTable();
  }
};

template<> inline const tflite::CustomQuantization *QuantizationParameters::details_as<tflite::CustomQuantization>() const {
  return details_as_CustomQuantization();
}

struct QuantizationParametersBuilder {
  typedef QuantizationParameters Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_min(::flatbuffers::Offset<::flatbuffers::Vector<float>> min) {
    fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
  }
  void add_max(::flatbuffers::Offset<::flatbuffers::Vector<float>> max) {
    fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
  }
  void add_scale(::flatbuffers::Offset<::flatbuffers::Vector<float>> scale) {
    fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
  }
  void add_zero_point(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> zero_point) {
    fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
  }
  void add_details_type(tflite::QuantizationDetails details_type) {
    fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
  }
  void add_details(::flatbuffers::Offset<void> details) {
    fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
  }
  void add_quantized_dimension(int32_t quantized_dimension) {
    fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0);
  }
  explicit QuantizationParametersBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<QuantizationParameters> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<QuantizationParameters>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> min = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> max = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> scale = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> zero_point = 0,
    tflite::QuantizationDetails details_type = tflite::QuantizationDetails::NONE,
    ::flatbuffers::Offset<void> details = 0,
    int32_t quantized_dimension = 0) {
  QuantizationParametersBuilder builder_(_fbb);
  builder_.add_quantized_dimension(quantized_dimension);
  builder_.add_details(details);
  builder_.add_zero_point(zero_point);
  builder_.add_scale(scale);
  builder_.add_max(max);
  builder_.add_min(min);
  builder_.add_details_type(details_type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<float> *min = nullptr,
    const std::vector<float> *max = nullptr,
    const std::vector<float> *scale = nullptr,
    const std::vector<int64_t> *zero_point = nullptr,
    tflite::QuantizationDetails details_type = tflite::QuantizationDetails::NONE,
    ::flatbuffers::Offset<void> details = 0,
    int32_t quantized_dimension = 0) {
  auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
  auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
  auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
  auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
  return tflite::CreateQuantizationParameters(
      _fbb,
      min__,
      max__,
      scale__,
      zero_point__,
      details_type,
      details,
      quantized_dimension);
}

struct Int32Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Int32VectorBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Int32VectorTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUES = 4
  };
  const ::flatbuffers::Vector<int32_t> *values() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_VALUES);
  }
  ::flatbuffers::Vector<int32_t> *mutable_values() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_VALUES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.VerifyVector(values()) &&
           verifier.EndTable();
  }
};

struct Int32VectorBuilder {
  typedef Int32Vector Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> values) {
    fbb_.AddOffset(Int32Vector::VT_VALUES, values);
  }
  explicit Int32VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Int32Vector> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Int32Vector>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Int32Vector> CreateInt32Vector(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> values = 0) {
  Int32VectorBuilder builder_(_fbb);
  builder_.add_values(values);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *values = nullptr) {
  auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
  return tflite::CreateInt32Vector(
      _fbb,
      values__);
}

struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Uint16VectorBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Uint16VectorTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUES = 4
  };
  const ::flatbuffers::Vector<uint16_t> *values() const {
    return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_VALUES);
  }
  ::flatbuffers::Vector<uint16_t> *mutable_values() {
    return GetPointer<::flatbuffers::Vector<uint16_t> *>(VT_VALUES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.VerifyVector(values()) &&
           verifier.EndTable();
  }
};

struct Uint16VectorBuilder {
  typedef Uint16Vector Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> values) {
    fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
  }
  explicit Uint16VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Uint16Vector> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Uint16Vector>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> values = 0) {
  Uint16VectorBuilder builder_(_fbb);
  builder_.add_values(values);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint16_t> *values = nullptr) {
  if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4); }
  auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
  return tflite::CreateUint16Vector(
      _fbb,
      values__);
}

struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Uint8VectorBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Uint8VectorTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUES = 4
  };
  const ::flatbuffers::Vector<uint8_t> *values() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_VALUES);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_values() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_VALUES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.VerifyVector(values()) &&
           verifier.EndTable();
  }
};

struct Uint8VectorBuilder {
  typedef Uint8Vector Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values) {
    fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
  }
  explicit Uint8VectorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Uint8Vector> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Uint8Vector>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> values = 0) {
  Uint8VectorBuilder builder_(_fbb);
  builder_.add_values(values);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *values = nullptr) {
  if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4); }
  auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
  return tflite::CreateUint8Vector(
      _fbb,
      values__);
}

struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DimensionMetadataBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DimensionMetadataTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FORMAT = 4,
    VT_DENSE_SIZE = 6,
    VT_ARRAY_SEGMENTS_TYPE = 8,
    VT_ARRAY_SEGMENTS = 10,
    VT_ARRAY_INDICES_TYPE = 12,
    VT_ARRAY_INDICES = 14
  };
  tflite::DimensionType format() const {
    return static_cast<tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
  }
  bool mutate_format(tflite::DimensionType _format = static_cast<tflite::DimensionType>(0)) {
    return SetField<int8_t>(VT_FORMAT, static_cast<int8_t>(_format), 0);
  }
  int32_t dense_size() const {
    return GetField<int32_t>(VT_DENSE_SIZE, 0);
  }
  bool mutate_dense_size(int32_t _dense_size = 0) {
    return SetField<int32_t>(VT_DENSE_SIZE, _dense_size, 0);
  }
  tflite::SparseIndexVector array_segments_type() const {
    return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
  }
  const void *array_segments() const {
    return GetPointer<const void *>(VT_ARRAY_SEGMENTS);
  }
  template<typename T> const T *array_segments_as() const;
  const tflite::Int32Vector *array_segments_as_Int32Vector() const {
    return array_segments_type() == tflite::SparseIndexVector::Int32Vector ? static_cast<const tflite::Int32Vector *>(array_segments()) : nullptr;
  }
  const tflite::Uint16Vector *array_segments_as_Uint16Vector() const {
    return array_segments_type() == tflite::SparseIndexVector::Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_segments()) : nullptr;
  }
  const tflite::Uint8Vector *array_segments_as_Uint8Vector() const {
    return array_segments_type() == tflite::SparseIndexVector::Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_segments()) : nullptr;
  }
  void *mutable_array_segments() {
    return GetPointer<void *>(VT_ARRAY_SEGMENTS);
  }
  tflite::SparseIndexVector array_indices_type() const {
    return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
  }
  const void *array_indices() const {
    return GetPointer<const void *>(VT_ARRAY_INDICES);
  }
  template<typename T> const T *array_indices_as() const;
  const tflite::Int32Vector *array_indices_as_Int32Vector() const {
    return array_indices_type() == tflite::SparseIndexVector::Int32Vector ? static_cast<const tflite::Int32Vector *>(array_indices()) : nullptr;
  }
  const tflite::Uint16Vector *array_indices_as_Uint16Vector() const {
    return array_indices_type() == tflite::SparseIndexVector::Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_indices()) : nullptr;
  }
  const tflite::Uint8Vector *array_indices_as_Uint8Vector() const {
    return array_indices_type() == tflite::SparseIndexVector::Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_indices()) : nullptr;
  }
  void *mutable_array_indices() {
    return GetPointer<void *>(VT_ARRAY_INDICES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FORMAT, 1) &&
           VerifyField<int32_t>(verifier, VT_DENSE_SIZE, 4) &&
           VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE, 1) &&
           VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
           VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
           VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE, 1) &&
           VerifyOffset(verifier, VT_ARRAY_INDICES) &&
           VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
           verifier.EndTable();
  }
};

template<> inline const tflite::Int32Vector *DimensionMetadata::array_segments_as<tflite::Int32Vector>() const {
  return array_segments_as_Int32Vector();
}

template<> inline const tflite::Uint16Vector *DimensionMetadata::array_segments_as<tflite::Uint16Vector>() const {
  return array_segments_as_Uint16Vector();
}

template<> inline const tflite::Uint8Vector *DimensionMetadata::array_segments_as<tflite::Uint8Vector>() const {
  return array_segments_as_Uint8Vector();
}

template<> inline const tflite::Int32Vector *DimensionMetadata::array_indices_as<tflite::Int32Vector>() const {
  return array_indices_as_Int32Vector();
}

template<> inline const tflite::Uint16Vector *DimensionMetadata::array_indices_as<tflite::Uint16Vector>() const {
  return array_indices_as_Uint16Vector();
}

template<> inline const tflite::Uint8Vector *DimensionMetadata::array_indices_as<tflite::Uint8Vector>() const {
  return array_indices_as_Uint8Vector();
}

struct DimensionMetadataBuilder {
  typedef DimensionMetadata Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_format(tflite::DimensionType format) {
    fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
  }
  void add_dense_size(int32_t dense_size) {
    fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
  }
  void add_array_segments_type(tflite::SparseIndexVector array_segments_type) {
    fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), 0);
  }
  void add_array_segments(::flatbuffers::Offset<void> array_segments) {
    fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
  }
  void add_array_indices_type(tflite::SparseIndexVector array_indices_type) {
    fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), 0);
  }
  void add_array_indices(::flatbuffers::Offset<void> array_indices) {
    fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
  }
  explicit DimensionMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DimensionMetadata> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DimensionMetadata>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::DimensionType format = tflite::DimensionType::DENSE,
    int32_t dense_size = 0,
    tflite::SparseIndexVector array_segments_type = tflite::SparseIndexVector::NONE,
    ::flatbuffers::Offset<void> array_segments = 0,
    tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector::NONE,
    ::flatbuffers::Offset<void> array_indices = 0) {
  DimensionMetadataBuilder builder_(_fbb);
  builder_.add_array_indices(array_indices);
  builder_.add_array_segments(array_segments);
  builder_.add_dense_size(dense_size);
  builder_.add_array_indices_type(array_indices_type);
  builder_.add_array_segments_type(array_segments_type);
  builder_.add_format(format);
  return builder_.Finish();
}

struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SparsityParametersBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SparsityParametersTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRAVERSAL_ORDER = 4,
    VT_BLOCK_MAP = 6,
    VT_DIM_METADATA = 8
  };
  const ::flatbuffers::Vector<int32_t> *traversal_order() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
  }
  ::flatbuffers::Vector<int32_t> *mutable_traversal_order() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
  }
  const ::flatbuffers::Vector<int32_t> *block_map() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
  }
  ::flatbuffers::Vector<int32_t> *mutable_block_map() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *mutable_dim_metadata() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
           verifier.VerifyVector(traversal_order()) &&
           VerifyOffset(verifier, VT_BLOCK_MAP) &&
           verifier.VerifyVector(block_map()) &&
           VerifyOffset(verifier, VT_DIM_METADATA) &&
           verifier.VerifyVector(dim_metadata()) &&
           verifier.VerifyVectorOfTables(dim_metadata()) &&
           verifier.EndTable();
  }
};

struct SparsityParametersBuilder {
  typedef SparsityParameters Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_traversal_order(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> traversal_order) {
    fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
  }
  void add_block_map(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> block_map) {
    fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
  }
  void add_dim_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
    fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
  }
  explicit SparsityParametersBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SparsityParameters> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SparsityParameters>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> traversal_order = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> block_map = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = 0) {
  SparsityParametersBuilder builder_(_fbb);
  builder_.add_dim_metadata(dim_metadata);
  builder_.add_block_map(block_map);
  builder_.add_traversal_order(traversal_order);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *traversal_order = nullptr,
    const std::vector<int32_t> *block_map = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata = nullptr) {
  auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
  auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
  auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<::flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : 0;
  return tflite::CreateSparsityParameters(
      _fbb,
      traversal_order__,
      block_map__,
      dim_metadata__);
}

struct VariantSubType FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VariantSubTypeBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return VariantSubTypeTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_TYPE = 6,
    VT_HAS_RANK = 8
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  ::flatbuffers::Vector<int32_t> *mutable_shape() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  tflite::TensorType type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
  }
  bool mutate_type(tflite::TensorType _type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_TYPE, static_cast<int8_t>(_type), 0);
  }
  bool has_rank() const {
    return GetField<uint8_t>(VT_HAS_RANK, 0) != 0;
  }
  bool mutate_has_rank(bool _has_rank = 0) {
    return SetField<uint8_t>(VT_HAS_RANK, static_cast<uint8_t>(_has_rank), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
           VerifyField<uint8_t>(verifier, VT_HAS_RANK, 1) &&
           verifier.EndTable();
  }
};

struct VariantSubTypeBuilder {
  typedef VariantSubType Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(VariantSubType::VT_SHAPE, shape);
  }
  void add_type(tflite::TensorType type) {
    fbb_.AddElement<int8_t>(VariantSubType::VT_TYPE, static_cast<int8_t>(type), 0);
  }
  void add_has_rank(bool has_rank) {
    fbb_.AddElement<uint8_t>(VariantSubType::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
  }
  explicit VariantSubTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VariantSubType> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VariantSubType>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VariantSubType> CreateVariantSubType(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    tflite::TensorType type = tflite::TensorType::FLOAT32,
    bool has_rank = false) {
  VariantSubTypeBuilder builder_(_fbb);
  builder_.add_shape(shape);
  builder_.add_has_rank(has_rank);
  builder_.add_type(type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VariantSubType> CreateVariantSubTypeDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    tflite::TensorType type = tflite::TensorType::FLOAT32,
    bool has_rank = false) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tflite::CreateVariantSubType(
      _fbb,
      shape__,
      type,
      has_rank);
}

struct Tensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TensorTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_TYPE = 6,
    VT_BUFFER = 8,
    VT_NAME = 10,
    VT_QUANTIZATION = 12,
    VT_IS_VARIABLE = 14,
    VT_SPARSITY = 16,
    VT_SHAPE_SIGNATURE = 18,
    VT_HAS_RANK = 20,
    VT_VARIANT_TENSORS = 22
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  ::flatbuffers::Vector<int32_t> *mutable_shape() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  tflite::TensorType type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
  }
  bool mutate_type(tflite::TensorType _type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_TYPE, static_cast<int8_t>(_type), 0);
  }
  uint32_t buffer() const {
    return GetField<uint32_t>(VT_BUFFER, 0);
  }
  bool mutate_buffer(uint32_t _buffer = 0) {
    return SetField<uint32_t>(VT_BUFFER, _buffer, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  const tflite::QuantizationParameters *quantization() const {
    return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
  }
  tflite::QuantizationParameters *mutable_quantization() {
    return GetPointer<tflite::QuantizationParameters *>(VT_QUANTIZATION);
  }
  bool is_variable() const {
    return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0;
  }
  bool mutate_is_variable(bool _is_variable = 0) {
    return SetField<uint8_t>(VT_IS_VARIABLE, static_cast<uint8_t>(_is_variable), 0);
  }
  const tflite::SparsityParameters *sparsity() const {
    return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
  }
  tflite::SparsityParameters *mutable_sparsity() {
    return GetPointer<tflite::SparsityParameters *>(VT_SPARSITY);
  }
  const ::flatbuffers::Vector<int32_t> *shape_signature() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
  }
  ::flatbuffers::Vector<int32_t> *mutable_shape_signature() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
  }
  bool has_rank() const {
    return GetField<uint8_t>(VT_HAS_RANK, 0) != 0;
  }
  bool mutate_has_rank(bool _has_rank = 0) {
    return SetField<uint8_t>(VT_HAS_RANK, static_cast<uint8_t>(_has_rank), 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *>(VT_VARIANT_TENSORS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *mutable_variant_tensors() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>> *>(VT_VARIANT_TENSORS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
           VerifyField<uint32_t>(verifier, VT_BUFFER, 4) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_QUANTIZATION) &&
           verifier.VerifyTable(quantization()) &&
           VerifyField<uint8_t>(verifier, VT_IS_VARIABLE, 1) &&
           VerifyOffset(verifier, VT_SPARSITY) &&
           verifier.VerifyTable(sparsity()) &&
           VerifyOffset(verifier, VT_SHAPE_SIGNATURE) &&
           verifier.VerifyVector(shape_signature()) &&
           VerifyField<uint8_t>(verifier, VT_HAS_RANK, 1) &&
           VerifyOffset(verifier, VT_VARIANT_TENSORS) &&
           verifier.VerifyVector(variant_tensors()) &&
           verifier.VerifyVectorOfTables(variant_tensors()) &&
           verifier.EndTable();
  }
};

struct TensorBuilder {
  typedef Tensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(Tensor::VT_SHAPE, shape);
  }
  void add_type(tflite::TensorType type) {
    fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
  }
  void add_buffer(uint32_t buffer) {
    fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Tensor::VT_NAME, name);
  }
  void add_quantization(::flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
    fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
  }
  void add_is_variable(bool is_variable) {
    fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
  }
  void add_sparsity(::flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
    fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
  }
  void add_shape_signature(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape_signature) {
    fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
  }
  void add_has_rank(bool has_rank) {
    fbb_.AddElement<uint8_t>(Tensor::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
  }
  void add_variant_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors) {
    fbb_.AddOffset(Tensor::VT_VARIANT_TENSORS, variant_tensors);
  }
  explicit TensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Tensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Tensor>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Tensor> CreateTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    tflite::TensorType type = tflite::TensorType::FLOAT32,
    uint32_t buffer = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
    bool is_variable = false,
    ::flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape_signature = 0,
    bool has_rank = false,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors = 0) {
  TensorBuilder builder_(_fbb);
  builder_.add_variant_tensors(variant_tensors);
  builder_.add_shape_signature(shape_signature);
  builder_.add_sparsity(sparsity);
  builder_.add_quantization(quantization);
  builder_.add_name(name);
  builder_.add_buffer(buffer);
  builder_.add_shape(shape);
  builder_.add_has_rank(has_rank);
  builder_.add_is_variable(is_variable);
  builder_.add_type(type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Tensor> CreateTensorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    tflite::TensorType type = tflite::TensorType::FLOAT32,
    uint32_t buffer = 0,
    const char *name = nullptr,
    ::flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
    bool is_variable = false,
    ::flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
    const std::vector<int32_t> *shape_signature = nullptr,
    bool has_rank = false,
    const std::vector<::flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors = nullptr) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
  auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<::flatbuffers::Offset<tflite::VariantSubType>>(*variant_tensors) : 0;
  return tflite::CreateTensor(
      _fbb,
      shape__,
      type,
      buffer,
      name__,
      quantization,
      is_variable,
      sparsity,
      shape_signature__,
      has_rank,
      variant_tensors__);
}

struct StablehloGatherOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloGatherOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloGatherOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OFFSET_DIMS = 4,
    VT_COLLAPSED_SLICE_DIMS = 6,
    VT_START_INDEX_MAP = 8,
    VT_INDEX_VECTOR_DIM = 10,
    VT_SLICE_SIZES = 12,
    VT_INDICES_ARE_SORTED = 14
  };
  const ::flatbuffers::Vector<int64_t> *offset_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_OFFSET_DIMS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_offset_dims() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_OFFSET_DIMS);
  }
  const ::flatbuffers::Vector<int64_t> *collapsed_slice_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_COLLAPSED_SLICE_DIMS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_collapsed_slice_dims() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_COLLAPSED_SLICE_DIMS);
  }
  const ::flatbuffers::Vector<int64_t> *start_index_map() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_START_INDEX_MAP);
  }
  ::flatbuffers::Vector<int64_t> *mutable_start_index_map() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_START_INDEX_MAP);
  }
  int64_t index_vector_dim() const {
    return GetField<int64_t>(VT_INDEX_VECTOR_DIM, 0);
  }
  bool mutate_index_vector_dim(int64_t _index_vector_dim = 0) {
    return SetField<int64_t>(VT_INDEX_VECTOR_DIM, _index_vector_dim, 0);
  }
  const ::flatbuffers::Vector<int64_t> *slice_sizes() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_slice_sizes() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
  }
  bool indices_are_sorted() const {
    return GetField<uint8_t>(VT_INDICES_ARE_SORTED, 0) != 0;
  }
  bool mutate_indices_are_sorted(bool _indices_are_sorted = 0) {
    return SetField<uint8_t>(VT_INDICES_ARE_SORTED, static_cast<uint8_t>(_indices_are_sorted), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OFFSET_DIMS) &&
           verifier.VerifyVector(offset_dims()) &&
           VerifyOffset(verifier, VT_COLLAPSED_SLICE_DIMS) &&
           verifier.VerifyVector(collapsed_slice_dims()) &&
           VerifyOffset(verifier, VT_START_INDEX_MAP) &&
           verifier.VerifyVector(start_index_map()) &&
           VerifyField<int64_t>(verifier, VT_INDEX_VECTOR_DIM, 8) &&
           VerifyOffset(verifier, VT_SLICE_SIZES) &&
           verifier.VerifyVector(slice_sizes()) &&
           VerifyField<uint8_t>(verifier, VT_INDICES_ARE_SORTED, 1) &&
           verifier.EndTable();
  }
};

struct StablehloGatherOptionsBuilder {
  typedef StablehloGatherOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_offset_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> offset_dims) {
    fbb_.AddOffset(StablehloGatherOptions::VT_OFFSET_DIMS, offset_dims);
  }
  void add_collapsed_slice_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> collapsed_slice_dims) {
    fbb_.AddOffset(StablehloGatherOptions::VT_COLLAPSED_SLICE_DIMS, collapsed_slice_dims);
  }
  void add_start_index_map(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_index_map) {
    fbb_.AddOffset(StablehloGatherOptions::VT_START_INDEX_MAP, start_index_map);
  }
  void add_index_vector_dim(int64_t index_vector_dim) {
    fbb_.AddElement<int64_t>(StablehloGatherOptions::VT_INDEX_VECTOR_DIM, index_vector_dim, 0);
  }
  void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes) {
    fbb_.AddOffset(StablehloGatherOptions::VT_SLICE_SIZES, slice_sizes);
  }
  void add_indices_are_sorted(bool indices_are_sorted) {
    fbb_.AddElement<uint8_t>(StablehloGatherOptions::VT_INDICES_ARE_SORTED, static_cast<uint8_t>(indices_are_sorted), 0);
  }
  explicit StablehloGatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloGatherOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloGatherOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> offset_dims = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> collapsed_slice_dims = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_index_map = 0,
    int64_t index_vector_dim = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes = 0,
    bool indices_are_sorted = false) {
  StablehloGatherOptionsBuilder builder_(_fbb);
  builder_.add_index_vector_dim(index_vector_dim);
  builder_.add_slice_sizes(slice_sizes);
  builder_.add_start_index_map(start_index_map);
  builder_.add_collapsed_slice_dims(collapsed_slice_dims);
  builder_.add_offset_dims(offset_dims);
  builder_.add_indices_are_sorted(indices_are_sorted);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloGatherOptions> CreateStablehloGatherOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *offset_dims = nullptr,
    const std::vector<int64_t> *collapsed_slice_dims = nullptr,
    const std::vector<int64_t> *start_index_map = nullptr,
    int64_t index_vector_dim = 0,
    const std::vector<int64_t> *slice_sizes = nullptr,
    bool indices_are_sorted = false) {
  auto offset_dims__ = offset_dims ? _fbb.CreateVector<int64_t>(*offset_dims) : 0;
  auto collapsed_slice_dims__ = collapsed_slice_dims ? _fbb.CreateVector<int64_t>(*collapsed_slice_dims) : 0;
  auto start_index_map__ = start_index_map ? _fbb.CreateVector<int64_t>(*start_index_map) : 0;
  auto slice_sizes__ = slice_sizes ? _fbb.CreateVector<int64_t>(*slice_sizes) : 0;
  return tflite::CreateStablehloGatherOptions(
      _fbb,
      offset_dims__,
      collapsed_slice_dims__,
      start_index_map__,
      index_vector_dim,
      slice_sizes__,
      indices_are_sorted);
}

struct StablehloTransposeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloTransposeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloTransposeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PERMUTATION = 4
  };
  const ::flatbuffers::Vector<int64_t> *permutation() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PERMUTATION);
  }
  ::flatbuffers::Vector<int64_t> *mutable_permutation() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_PERMUTATION);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PERMUTATION) &&
           verifier.VerifyVector(permutation()) &&
           verifier.EndTable();
  }
};

struct StablehloTransposeOptionsBuilder {
  typedef StablehloTransposeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_permutation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation) {
    fbb_.AddOffset(StablehloTransposeOptions::VT_PERMUTATION, permutation);
  }
  explicit StablehloTransposeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloTransposeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloTransposeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation = 0) {
  StablehloTransposeOptionsBuilder builder_(_fbb);
  builder_.add_permutation(permutation);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloTransposeOptions> CreateStablehloTransposeOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *permutation = nullptr) {
  auto permutation__ = permutation ? _fbb.CreateVector<int64_t>(*permutation) : 0;
  return tflite::CreateStablehloTransposeOptions(
      _fbb,
      permutation__);
}

struct StablehloDotGeneralOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloDotGeneralOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloDotGeneralOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LHS_BATCHING_DIMENSIONS = 4,
    VT_RHS_BATCHING_DIMENSIONS = 6,
    VT_LHS_CONTRACTING_DIMENSIONS = 8,
    VT_RHS_CONTRACTING_DIMENSIONS = 10,
    VT_PRECISION_CONFIG = 12
  };
  const ::flatbuffers::Vector<int64_t> *lhs_batching_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_BATCHING_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_lhs_batching_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_LHS_BATCHING_DIMENSIONS);
  }
  const ::flatbuffers::Vector<int64_t> *rhs_batching_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_BATCHING_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_rhs_batching_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_RHS_BATCHING_DIMENSIONS);
  }
  const ::flatbuffers::Vector<int64_t> *lhs_contracting_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_CONTRACTING_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_lhs_contracting_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_LHS_CONTRACTING_DIMENSIONS);
  }
  const ::flatbuffers::Vector<int64_t> *rhs_contracting_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_CONTRACTING_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_rhs_contracting_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_RHS_CONTRACTING_DIMENSIONS);
  }
  const ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *precision_config() const {
    return GetPointer<const ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *>(VT_PRECISION_CONFIG);
  }
  ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *mutable_precision_config() {
    return GetPointer<::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *>(VT_PRECISION_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_LHS_BATCHING_DIMENSIONS) &&
           verifier.VerifyVector(lhs_batching_dimensions()) &&
           VerifyOffset(verifier, VT_RHS_BATCHING_DIMENSIONS) &&
           verifier.VerifyVector(rhs_batching_dimensions()) &&
           VerifyOffset(verifier, VT_LHS_CONTRACTING_DIMENSIONS) &&
           verifier.VerifyVector(lhs_contracting_dimensions()) &&
           VerifyOffset(verifier, VT_RHS_CONTRACTING_DIMENSIONS) &&
           verifier.VerifyVector(rhs_contracting_dimensions()) &&
           VerifyOffset(verifier, VT_PRECISION_CONFIG) &&
           verifier.VerifyVector(precision_config()) &&
           verifier.EndTable();
  }
};

struct StablehloDotGeneralOptionsBuilder {
  typedef StablehloDotGeneralOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_lhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_batching_dimensions) {
    fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_BATCHING_DIMENSIONS, lhs_batching_dimensions);
  }
  void add_rhs_batching_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_batching_dimensions) {
    fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_BATCHING_DIMENSIONS, rhs_batching_dimensions);
  }
  void add_lhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_contracting_dimensions) {
    fbb_.AddOffset(StablehloDotGeneralOptions::VT_LHS_CONTRACTING_DIMENSIONS, lhs_contracting_dimensions);
  }
  void add_rhs_contracting_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_contracting_dimensions) {
    fbb_.AddOffset(StablehloDotGeneralOptions::VT_RHS_CONTRACTING_DIMENSIONS, rhs_contracting_dimensions);
  }
  void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector<tflite::StablehloPrecisionConfig>> precision_config) {
    fbb_.AddOffset(StablehloDotGeneralOptions::VT_PRECISION_CONFIG, precision_config);
  }
  explicit StablehloDotGeneralOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloDotGeneralOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloDotGeneralOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_batching_dimensions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_batching_dimensions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_contracting_dimensions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_contracting_dimensions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<tflite::StablehloPrecisionConfig>> precision_config = 0) {
  StablehloDotGeneralOptionsBuilder builder_(_fbb);
  builder_.add_precision_config(precision_config);
  builder_.add_rhs_contracting_dimensions(rhs_contracting_dimensions);
  builder_.add_lhs_contracting_dimensions(lhs_contracting_dimensions);
  builder_.add_rhs_batching_dimensions(rhs_batching_dimensions);
  builder_.add_lhs_batching_dimensions(lhs_batching_dimensions);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloDotGeneralOptions> CreateStablehloDotGeneralOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *lhs_batching_dimensions = nullptr,
    const std::vector<int64_t> *rhs_batching_dimensions = nullptr,
    const std::vector<int64_t> *lhs_contracting_dimensions = nullptr,
    const std::vector<int64_t> *rhs_contracting_dimensions = nullptr,
    const std::vector<tflite::StablehloPrecisionConfig> *precision_config = nullptr) {
  auto lhs_batching_dimensions__ = lhs_batching_dimensions ? _fbb.CreateVector<int64_t>(*lhs_batching_dimensions) : 0;
  auto rhs_batching_dimensions__ = rhs_batching_dimensions ? _fbb.CreateVector<int64_t>(*rhs_batching_dimensions) : 0;
  auto lhs_contracting_dimensions__ = lhs_contracting_dimensions ? _fbb.CreateVector<int64_t>(*lhs_contracting_dimensions) : 0;
  auto rhs_contracting_dimensions__ = rhs_contracting_dimensions ? _fbb.CreateVector<int64_t>(*rhs_contracting_dimensions) : 0;
  auto precision_config__ = precision_config ? _fbb.CreateVector<tflite::StablehloPrecisionConfig>(*precision_config) : 0;
  return tflite::CreateStablehloDotGeneralOptions(
      _fbb,
      lhs_batching_dimensions__,
      rhs_batching_dimensions__,
      lhs_contracting_dimensions__,
      rhs_contracting_dimensions__,
      precision_config__);
}

struct StablehloReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloReduceWindowOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloReduceWindowOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WINDOW_DIMENSIONS = 4,
    VT_WINDOW_STRIDES = 6,
    VT_BASE_DILATIONS = 8,
    VT_WINDOW_DILATIONS = 10,
    VT_PADDING = 12,
    VT_BODY_SUBGRAPH_INDEX = 14
  };
  const ::flatbuffers::Vector<int64_t> *window_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_window_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DIMENSIONS);
  }
  const ::flatbuffers::Vector<int64_t> *window_strides() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_window_strides() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
  }
  const ::flatbuffers::Vector<int64_t> *base_dilations() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_BASE_DILATIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_base_dilations() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_BASE_DILATIONS);
  }
  const ::flatbuffers::Vector<int64_t> *window_dilations() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DILATIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_window_dilations() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_WINDOW_DILATIONS);
  }
  const ::flatbuffers::Vector<int64_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PADDING);
  }
  ::flatbuffers::Vector<int64_t> *mutable_padding() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_PADDING);
  }
  int32_t body_subgraph_index() const {
    return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
  }
  bool mutate_body_subgraph_index(int32_t _body_subgraph_index = 0) {
    return SetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, _body_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WINDOW_DIMENSIONS) &&
           verifier.VerifyVector(window_dimensions()) &&
           VerifyOffset(verifier, VT_WINDOW_STRIDES) &&
           verifier.VerifyVector(window_strides()) &&
           VerifyOffset(verifier, VT_BASE_DILATIONS) &&
           verifier.VerifyVector(base_dilations()) &&
           VerifyOffset(verifier, VT_WINDOW_DILATIONS) &&
           verifier.VerifyVector(window_dilations()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct StablehloReduceWindowOptionsBuilder {
  typedef StablehloReduceWindowOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_window_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dimensions) {
    fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DIMENSIONS, window_dimensions);
  }
  void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides) {
    fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_STRIDES, window_strides);
  }
  void add_base_dilations(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> base_dilations) {
    fbb_.AddOffset(StablehloReduceWindowOptions::VT_BASE_DILATIONS, base_dilations);
  }
  void add_window_dilations(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dilations) {
    fbb_.AddOffset(StablehloReduceWindowOptions::VT_WINDOW_DILATIONS, window_dilations);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding) {
    fbb_.AddOffset(StablehloReduceWindowOptions::VT_PADDING, padding);
  }
  void add_body_subgraph_index(int32_t body_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloReduceWindowOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
  }
  explicit StablehloReduceWindowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloReduceWindowOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloReduceWindowOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dimensions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> base_dilations = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_dilations = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding = 0,
    int32_t body_subgraph_index = 0) {
  StablehloReduceWindowOptionsBuilder builder_(_fbb);
  builder_.add_body_subgraph_index(body_subgraph_index);
  builder_.add_padding(padding);
  builder_.add_window_dilations(window_dilations);
  builder_.add_base_dilations(base_dilations);
  builder_.add_window_strides(window_strides);
  builder_.add_window_dimensions(window_dimensions);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloReduceWindowOptions> CreateStablehloReduceWindowOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *window_dimensions = nullptr,
    const std::vector<int64_t> *window_strides = nullptr,
    const std::vector<int64_t> *base_dilations = nullptr,
    const std::vector<int64_t> *window_dilations = nullptr,
    const std::vector<int64_t> *padding = nullptr,
    int32_t body_subgraph_index = 0) {
  auto window_dimensions__ = window_dimensions ? _fbb.CreateVector<int64_t>(*window_dimensions) : 0;
  auto window_strides__ = window_strides ? _fbb.CreateVector<int64_t>(*window_strides) : 0;
  auto base_dilations__ = base_dilations ? _fbb.CreateVector<int64_t>(*base_dilations) : 0;
  auto window_dilations__ = window_dilations ? _fbb.CreateVector<int64_t>(*window_dilations) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int64_t>(*padding) : 0;
  return tflite::CreateStablehloReduceWindowOptions(
      _fbb,
      window_dimensions__,
      window_strides__,
      base_dilations__,
      window_dilations__,
      padding__,
      body_subgraph_index);
}

struct StablehloWhileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloWhileOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloWhileOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COND_SUBGRAPH_INDEX = 4,
    VT_BODY_SUBGRAPH_INDEX = 6
  };
  int32_t cond_subgraph_index() const {
    return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0);
  }
  bool mutate_cond_subgraph_index(int32_t _cond_subgraph_index = 0) {
    return SetField<int32_t>(VT_COND_SUBGRAPH_INDEX, _cond_subgraph_index, 0);
  }
  int32_t body_subgraph_index() const {
    return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
  }
  bool mutate_body_subgraph_index(int32_t _body_subgraph_index = 0) {
    return SetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, _body_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, 4) &&
           VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct StablehloWhileOptionsBuilder {
  typedef StablehloWhileOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_cond_subgraph_index(int32_t cond_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloWhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
  }
  void add_body_subgraph_index(int32_t body_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloWhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
  }
  explicit StablehloWhileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloWhileOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloWhileOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloWhileOptions> CreateStablehloWhileOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t cond_subgraph_index = 0,
    int32_t body_subgraph_index = 0) {
  StablehloWhileOptionsBuilder builder_(_fbb);
  builder_.add_body_subgraph_index(body_subgraph_index);
  builder_.add_cond_subgraph_index(cond_subgraph_index);
  return builder_.Finish();
}

struct StablehloSortOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloSortOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloSortOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DIMENSION = 4,
    VT_IS_STABLE = 6,
    VT_COMPARATOR_SUBGRAPH_INDEX = 8
  };
  int64_t dimension() const {
    return GetField<int64_t>(VT_DIMENSION, 0);
  }
  bool mutate_dimension(int64_t _dimension = 0) {
    return SetField<int64_t>(VT_DIMENSION, _dimension, 0);
  }
  bool is_stable() const {
    return GetField<uint8_t>(VT_IS_STABLE, 0) != 0;
  }
  bool mutate_is_stable(bool _is_stable = 0) {
    return SetField<uint8_t>(VT_IS_STABLE, static_cast<uint8_t>(_is_stable), 0);
  }
  int32_t comparator_subgraph_index() const {
    return GetField<int32_t>(VT_COMPARATOR_SUBGRAPH_INDEX, 0);
  }
  bool mutate_comparator_subgraph_index(int32_t _comparator_subgraph_index = 0) {
    return SetField<int32_t>(VT_COMPARATOR_SUBGRAPH_INDEX, _comparator_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_DIMENSION, 8) &&
           VerifyField<uint8_t>(verifier, VT_IS_STABLE, 1) &&
           VerifyField<int32_t>(verifier, VT_COMPARATOR_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct StablehloSortOptionsBuilder {
  typedef StablehloSortOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dimension(int64_t dimension) {
    fbb_.AddElement<int64_t>(StablehloSortOptions::VT_DIMENSION, dimension, 0);
  }
  void add_is_stable(bool is_stable) {
    fbb_.AddElement<uint8_t>(StablehloSortOptions::VT_IS_STABLE, static_cast<uint8_t>(is_stable), 0);
  }
  void add_comparator_subgraph_index(int32_t comparator_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloSortOptions::VT_COMPARATOR_SUBGRAPH_INDEX, comparator_subgraph_index, 0);
  }
  explicit StablehloSortOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloSortOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloSortOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloSortOptions> CreateStablehloSortOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t dimension = 0,
    bool is_stable = false,
    int32_t comparator_subgraph_index = 0) {
  StablehloSortOptionsBuilder builder_(_fbb);
  builder_.add_dimension(dimension);
  builder_.add_comparator_subgraph_index(comparator_subgraph_index);
  builder_.add_is_stable(is_stable);
  return builder_.Finish();
}

struct StablehloConcatenateOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloConcatenateOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloConcatenateOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DIMENSION = 4
  };
  int64_t dimension() const {
    return GetField<int64_t>(VT_DIMENSION, 0);
  }
  bool mutate_dimension(int64_t _dimension = 0) {
    return SetField<int64_t>(VT_DIMENSION, _dimension, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_DIMENSION, 8) &&
           verifier.EndTable();
  }
};

struct StablehloConcatenateOptionsBuilder {
  typedef StablehloConcatenateOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dimension(int64_t dimension) {
    fbb_.AddElement<int64_t>(StablehloConcatenateOptions::VT_DIMENSION, dimension, 0);
  }
  explicit StablehloConcatenateOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloConcatenateOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloConcatenateOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloConcatenateOptions> CreateStablehloConcatenateOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t dimension = 0) {
  StablehloConcatenateOptionsBuilder builder_(_fbb);
  builder_.add_dimension(dimension);
  return builder_.Finish();
}

struct StablehloBroadcastInDimOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloBroadcastInDimOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloBroadcastInDimOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BROADCAST_DIMENSIONS = 4
  };
  const ::flatbuffers::Vector<int64_t> *broadcast_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_BROADCAST_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_broadcast_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_BROADCAST_DIMENSIONS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_BROADCAST_DIMENSIONS) &&
           verifier.VerifyVector(broadcast_dimensions()) &&
           verifier.EndTable();
  }
};

struct StablehloBroadcastInDimOptionsBuilder {
  typedef StablehloBroadcastInDimOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_broadcast_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> broadcast_dimensions) {
    fbb_.AddOffset(StablehloBroadcastInDimOptions::VT_BROADCAST_DIMENSIONS, broadcast_dimensions);
  }
  explicit StablehloBroadcastInDimOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloBroadcastInDimOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloBroadcastInDimOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> broadcast_dimensions = 0) {
  StablehloBroadcastInDimOptionsBuilder builder_(_fbb);
  builder_.add_broadcast_dimensions(broadcast_dimensions);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloBroadcastInDimOptions> CreateStablehloBroadcastInDimOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *broadcast_dimensions = nullptr) {
  auto broadcast_dimensions__ = broadcast_dimensions ? _fbb.CreateVector<int64_t>(*broadcast_dimensions) : 0;
  return tflite::CreateStablehloBroadcastInDimOptions(
      _fbb,
      broadcast_dimensions__);
}

struct StablehloCompareOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloCompareOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloCompareOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMPARISON_DIRECTION = 4,
    VT_COMPARE_TYPE = 6
  };
  tflite::StablehloComparisonDirection comparison_direction() const {
    return static_cast<tflite::StablehloComparisonDirection>(GetField<uint32_t>(VT_COMPARISON_DIRECTION, 0));
  }
  bool mutate_comparison_direction(tflite::StablehloComparisonDirection _comparison_direction = static_cast<tflite::StablehloComparisonDirection>(0)) {
    return SetField<uint32_t>(VT_COMPARISON_DIRECTION, static_cast<uint32_t>(_comparison_direction), 0);
  }
  tflite::StablehloComparisonType compare_type() const {
    return static_cast<tflite::StablehloComparisonType>(GetField<uint32_t>(VT_COMPARE_TYPE, 0));
  }
  bool mutate_compare_type(tflite::StablehloComparisonType _compare_type = static_cast<tflite::StablehloComparisonType>(0)) {
    return SetField<uint32_t>(VT_COMPARE_TYPE, static_cast<uint32_t>(_compare_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_COMPARISON_DIRECTION, 4) &&
           VerifyField<uint32_t>(verifier, VT_COMPARE_TYPE, 4) &&
           verifier.EndTable();
  }
};

struct StablehloCompareOptionsBuilder {
  typedef StablehloCompareOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_comparison_direction(tflite::StablehloComparisonDirection comparison_direction) {
    fbb_.AddElement<uint32_t>(StablehloCompareOptions::VT_COMPARISON_DIRECTION, static_cast<uint32_t>(comparison_direction), 0);
  }
  void add_compare_type(tflite::StablehloComparisonType compare_type) {
    fbb_.AddElement<uint32_t>(StablehloCompareOptions::VT_COMPARE_TYPE, static_cast<uint32_t>(compare_type), 0);
  }
  explicit StablehloCompareOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloCompareOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloCompareOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloCompareOptions> CreateStablehloCompareOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::StablehloComparisonDirection comparison_direction = tflite::StablehloComparisonDirection::STABLEHLO_COMPARISON_DIRECTION_EQ,
    tflite::StablehloComparisonType compare_type = tflite::StablehloComparisonType::STABLEHLO_COMPARISON_TYPE_NOTYPE) {
  StablehloCompareOptionsBuilder builder_(_fbb);
  builder_.add_compare_type(compare_type);
  builder_.add_comparison_direction(comparison_direction);
  return builder_.Finish();
}

struct StablehloDynamicSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloDynamicSliceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloDynamicSliceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SLICE_SIZES = 4
  };
  const ::flatbuffers::Vector<int64_t> *slice_sizes() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_slice_sizes() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_SLICE_SIZES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SLICE_SIZES) &&
           verifier.VerifyVector(slice_sizes()) &&
           verifier.EndTable();
  }
};

struct StablehloDynamicSliceOptionsBuilder {
  typedef StablehloDynamicSliceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_slice_sizes(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes) {
    fbb_.AddOffset(StablehloDynamicSliceOptions::VT_SLICE_SIZES, slice_sizes);
  }
  explicit StablehloDynamicSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloDynamicSliceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloDynamicSliceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> slice_sizes = 0) {
  StablehloDynamicSliceOptionsBuilder builder_(_fbb);
  builder_.add_slice_sizes(slice_sizes);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloDynamicSliceOptions> CreateStablehloDynamicSliceOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *slice_sizes = nullptr) {
  auto slice_sizes__ = slice_sizes ? _fbb.CreateVector<int64_t>(*slice_sizes) : 0;
  return tflite::CreateStablehloDynamicSliceOptions(
      _fbb,
      slice_sizes__);
}

struct StablehloPadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloPadOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloPadOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_EDGE_PADDING_LOW = 4,
    VT_EDGE_PADDING_HIGH = 6,
    VT_INTERIOR_PADDING = 8
  };
  const ::flatbuffers::Vector<int64_t> *edge_padding_low() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_LOW);
  }
  ::flatbuffers::Vector<int64_t> *mutable_edge_padding_low() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_LOW);
  }
  const ::flatbuffers::Vector<int64_t> *edge_padding_high() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_HIGH);
  }
  ::flatbuffers::Vector<int64_t> *mutable_edge_padding_high() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_EDGE_PADDING_HIGH);
  }
  const ::flatbuffers::Vector<int64_t> *interior_padding() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INTERIOR_PADDING);
  }
  ::flatbuffers::Vector<int64_t> *mutable_interior_padding() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_INTERIOR_PADDING);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_EDGE_PADDING_LOW) &&
           verifier.VerifyVector(edge_padding_low()) &&
           VerifyOffset(verifier, VT_EDGE_PADDING_HIGH) &&
           verifier.VerifyVector(edge_padding_high()) &&
           VerifyOffset(verifier, VT_INTERIOR_PADDING) &&
           verifier.VerifyVector(interior_padding()) &&
           verifier.EndTable();
  }
};

struct StablehloPadOptionsBuilder {
  typedef StablehloPadOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_edge_padding_low(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_low) {
    fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_LOW, edge_padding_low);
  }
  void add_edge_padding_high(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_high) {
    fbb_.AddOffset(StablehloPadOptions::VT_EDGE_PADDING_HIGH, edge_padding_high);
  }
  void add_interior_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> interior_padding) {
    fbb_.AddOffset(StablehloPadOptions::VT_INTERIOR_PADDING, interior_padding);
  }
  explicit StablehloPadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloPadOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloPadOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_low = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> edge_padding_high = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> interior_padding = 0) {
  StablehloPadOptionsBuilder builder_(_fbb);
  builder_.add_interior_padding(interior_padding);
  builder_.add_edge_padding_high(edge_padding_high);
  builder_.add_edge_padding_low(edge_padding_low);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloPadOptions> CreateStablehloPadOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *edge_padding_low = nullptr,
    const std::vector<int64_t> *edge_padding_high = nullptr,
    const std::vector<int64_t> *interior_padding = nullptr) {
  auto edge_padding_low__ = edge_padding_low ? _fbb.CreateVector<int64_t>(*edge_padding_low) : 0;
  auto edge_padding_high__ = edge_padding_high ? _fbb.CreateVector<int64_t>(*edge_padding_high) : 0;
  auto interior_padding__ = interior_padding ? _fbb.CreateVector<int64_t>(*interior_padding) : 0;
  return tflite::CreateStablehloPadOptions(
      _fbb,
      edge_padding_low__,
      edge_padding_high__,
      interior_padding__);
}

struct StablehloIotaOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloIotaOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloIotaOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IOTA_DIMENSION = 4
  };
  int64_t iota_dimension() const {
    return GetField<int64_t>(VT_IOTA_DIMENSION, 0);
  }
  bool mutate_iota_dimension(int64_t _iota_dimension = 0) {
    return SetField<int64_t>(VT_IOTA_DIMENSION, _iota_dimension, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_IOTA_DIMENSION, 8) &&
           verifier.EndTable();
  }
};

struct StablehloIotaOptionsBuilder {
  typedef StablehloIotaOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_iota_dimension(int64_t iota_dimension) {
    fbb_.AddElement<int64_t>(StablehloIotaOptions::VT_IOTA_DIMENSION, iota_dimension, 0);
  }
  explicit StablehloIotaOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloIotaOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloIotaOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloIotaOptions> CreateStablehloIotaOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t iota_dimension = 0) {
  StablehloIotaOptionsBuilder builder_(_fbb);
  builder_.add_iota_dimension(iota_dimension);
  return builder_.Finish();
}

struct StablehloCustomCallOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloCustomCallOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloCustomCallOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CALL_TARGET_NAME = 4,
    VT_HAS_SIDE_EFFECT = 6,
    VT_BACKEND_CONFIG = 8,
    VT_API_VERSION = 10,
    VT_CALLED_COMPUTATIONS = 12,
    VT_CUSTOM_ATTRIBUTES = 14
  };
  const ::flatbuffers::String *call_target_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CALL_TARGET_NAME);
  }
  ::flatbuffers::String *mutable_call_target_name() {
    return GetPointer<::flatbuffers::String *>(VT_CALL_TARGET_NAME);
  }
  bool has_side_effect() const {
    return GetField<uint8_t>(VT_HAS_SIDE_EFFECT, 0) != 0;
  }
  bool mutate_has_side_effect(bool _has_side_effect = 0) {
    return SetField<uint8_t>(VT_HAS_SIDE_EFFECT, static_cast<uint8_t>(_has_side_effect), 0);
  }
  const ::flatbuffers::String *backend_config() const {
    return GetPointer<const ::flatbuffers::String *>(VT_BACKEND_CONFIG);
  }
  ::flatbuffers::String *mutable_backend_config() {
    return GetPointer<::flatbuffers::String *>(VT_BACKEND_CONFIG);
  }
  int32_t api_version() const {
    return GetField<int32_t>(VT_API_VERSION, 0);
  }
  bool mutate_api_version(int32_t _api_version = 0) {
    return SetField<int32_t>(VT_API_VERSION, _api_version, 0);
  }
  const ::flatbuffers::Vector<int32_t> *called_computations() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_CALLED_COMPUTATIONS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_called_computations() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_CALLED_COMPUTATIONS);
  }
  const ::flatbuffers::Vector<uint8_t> *custom_attributes() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_ATTRIBUTES);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_custom_attributes() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_ATTRIBUTES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CALL_TARGET_NAME) &&
           verifier.VerifyString(call_target_name()) &&
           VerifyField<uint8_t>(verifier, VT_HAS_SIDE_EFFECT, 1) &&
           VerifyOffset(verifier, VT_BACKEND_CONFIG) &&
           verifier.VerifyString(backend_config()) &&
           VerifyField<int32_t>(verifier, VT_API_VERSION, 4) &&
           VerifyOffset(verifier, VT_CALLED_COMPUTATIONS) &&
           verifier.VerifyVector(called_computations()) &&
           VerifyOffset(verifier, VT_CUSTOM_ATTRIBUTES) &&
           verifier.VerifyVector(custom_attributes()) &&
           verifier.EndTable();
  }
};

struct StablehloCustomCallOptionsBuilder {
  typedef StablehloCustomCallOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_call_target_name(::flatbuffers::Offset<::flatbuffers::String> call_target_name) {
    fbb_.AddOffset(StablehloCustomCallOptions::VT_CALL_TARGET_NAME, call_target_name);
  }
  void add_has_side_effect(bool has_side_effect) {
    fbb_.AddElement<uint8_t>(StablehloCustomCallOptions::VT_HAS_SIDE_EFFECT, static_cast<uint8_t>(has_side_effect), 0);
  }
  void add_backend_config(::flatbuffers::Offset<::flatbuffers::String> backend_config) {
    fbb_.AddOffset(StablehloCustomCallOptions::VT_BACKEND_CONFIG, backend_config);
  }
  void add_api_version(int32_t api_version) {
    fbb_.AddElement<int32_t>(StablehloCustomCallOptions::VT_API_VERSION, api_version, 0);
  }
  void add_called_computations(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> called_computations) {
    fbb_.AddOffset(StablehloCustomCallOptions::VT_CALLED_COMPUTATIONS, called_computations);
  }
  void add_custom_attributes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_attributes) {
    fbb_.AddOffset(StablehloCustomCallOptions::VT_CUSTOM_ATTRIBUTES, custom_attributes);
  }
  explicit StablehloCustomCallOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloCustomCallOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloCustomCallOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> call_target_name = 0,
    bool has_side_effect = false,
    ::flatbuffers::Offset<::flatbuffers::String> backend_config = 0,
    int32_t api_version = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> called_computations = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_attributes = 0) {
  StablehloCustomCallOptionsBuilder builder_(_fbb);
  builder_.add_custom_attributes(custom_attributes);
  builder_.add_called_computations(called_computations);
  builder_.add_api_version(api_version);
  builder_.add_backend_config(backend_config);
  builder_.add_call_target_name(call_target_name);
  builder_.add_has_side_effect(has_side_effect);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloCustomCallOptions> CreateStablehloCustomCallOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *call_target_name = nullptr,
    bool has_side_effect = false,
    const char *backend_config = nullptr,
    int32_t api_version = 0,
    const std::vector<int32_t> *called_computations = nullptr,
    const std::vector<uint8_t> *custom_attributes = nullptr) {
  auto call_target_name__ = call_target_name ? _fbb.CreateString(call_target_name) : 0;
  auto backend_config__ = backend_config ? _fbb.CreateString(backend_config) : 0;
  auto called_computations__ = called_computations ? _fbb.CreateVector<int32_t>(*called_computations) : 0;
  auto custom_attributes__ = custom_attributes ? _fbb.CreateVector<uint8_t>(*custom_attributes) : 0;
  return tflite::CreateStablehloCustomCallOptions(
      _fbb,
      call_target_name__,
      has_side_effect,
      backend_config__,
      api_version,
      called_computations__,
      custom_attributes__);
}

struct StablehloReduceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloReduceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloReduceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DIMENSIONS = 4,
    VT_BODY_SUBGRAPH_INDEX = 6
  };
  const ::flatbuffers::Vector<int64_t> *dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_DIMENSIONS);
  }
  int32_t body_subgraph_index() const {
    return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
  }
  bool mutate_body_subgraph_index(int32_t _body_subgraph_index = 0) {
    return SetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, _body_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DIMENSIONS) &&
           verifier.VerifyVector(dimensions()) &&
           VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct StablehloReduceOptionsBuilder {
  typedef StablehloReduceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> dimensions) {
    fbb_.AddOffset(StablehloReduceOptions::VT_DIMENSIONS, dimensions);
  }
  void add_body_subgraph_index(int32_t body_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloReduceOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
  }
  explicit StablehloReduceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloReduceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloReduceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> dimensions = 0,
    int32_t body_subgraph_index = 0) {
  StablehloReduceOptionsBuilder builder_(_fbb);
  builder_.add_body_subgraph_index(body_subgraph_index);
  builder_.add_dimensions(dimensions);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloReduceOptions> CreateStablehloReduceOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *dimensions = nullptr,
    int32_t body_subgraph_index = 0) {
  auto dimensions__ = dimensions ? _fbb.CreateVector<int64_t>(*dimensions) : 0;
  return tflite::CreateStablehloReduceOptions(
      _fbb,
      dimensions__,
      body_subgraph_index);
}

struct StablehloSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloSliceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloSliceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_START_INDICES = 4,
    VT_LIMIT_INDICES = 6,
    VT_STRIDES = 8
  };
  const ::flatbuffers::Vector<int64_t> *start_indices() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_START_INDICES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_start_indices() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_START_INDICES);
  }
  const ::flatbuffers::Vector<int64_t> *limit_indices() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LIMIT_INDICES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_limit_indices() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_LIMIT_INDICES);
  }
  const ::flatbuffers::Vector<int64_t> *strides() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_STRIDES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_strides() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_STRIDES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_START_INDICES) &&
           verifier.VerifyVector(start_indices()) &&
           VerifyOffset(verifier, VT_LIMIT_INDICES) &&
           verifier.VerifyVector(limit_indices()) &&
           VerifyOffset(verifier, VT_STRIDES) &&
           verifier.VerifyVector(strides()) &&
           verifier.EndTable();
  }
};

struct StablehloSliceOptionsBuilder {
  typedef StablehloSliceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_start_indices(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_indices) {
    fbb_.AddOffset(StablehloSliceOptions::VT_START_INDICES, start_indices);
  }
  void add_limit_indices(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> limit_indices) {
    fbb_.AddOffset(StablehloSliceOptions::VT_LIMIT_INDICES, limit_indices);
  }
  void add_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides) {
    fbb_.AddOffset(StablehloSliceOptions::VT_STRIDES, strides);
  }
  explicit StablehloSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloSliceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloSliceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> start_indices = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> limit_indices = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides = 0) {
  StablehloSliceOptionsBuilder builder_(_fbb);
  builder_.add_strides(strides);
  builder_.add_limit_indices(limit_indices);
  builder_.add_start_indices(start_indices);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloSliceOptions> CreateStablehloSliceOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *start_indices = nullptr,
    const std::vector<int64_t> *limit_indices = nullptr,
    const std::vector<int64_t> *strides = nullptr) {
  auto start_indices__ = start_indices ? _fbb.CreateVector<int64_t>(*start_indices) : 0;
  auto limit_indices__ = limit_indices ? _fbb.CreateVector<int64_t>(*limit_indices) : 0;
  auto strides__ = strides ? _fbb.CreateVector<int64_t>(*strides) : 0;
  return tflite::CreateStablehloSliceOptions(
      _fbb,
      start_indices__,
      limit_indices__,
      strides__);
}

struct StablehloConvolutionOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloConvolutionOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloConvolutionOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WINDOW_STRIDES = 4,
    VT_PADDING = 6,
    VT_LHS_DILATION = 8,
    VT_RHS_DILATION = 10,
    VT_WINDOW_REVERSAL = 12,
    VT_INPUT_BATCH_DIMENSION = 14,
    VT_INPUT_FEATURE_DIMENSION = 16,
    VT_INPUT_SPATIAL_DIMENSIONS = 18,
    VT_KERNEL_INPUT_FEATURE_DIMENSION = 20,
    VT_KERNEL_OUTPUT_FEATURE_DIMENSION = 22,
    VT_KERNEL_SPATIAL_DIMENSIONS = 24,
    VT_OUTPUT_BATCH_DIMENSION = 26,
    VT_OUTPUT_FEATURE_DIMENSION = 28,
    VT_OUTPUT_SPATIAL_DIMENSIONS = 30,
    VT_FEATURE_GROUP_COUNT = 32,
    VT_BATCH_GROUP_COUNT = 34,
    VT_PRECISION_CONFIG = 36
  };
  const ::flatbuffers::Vector<int64_t> *window_strides() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
  }
  ::flatbuffers::Vector<int64_t> *mutable_window_strides() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_WINDOW_STRIDES);
  }
  const ::flatbuffers::Vector<int64_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PADDING);
  }
  ::flatbuffers::Vector<int64_t> *mutable_padding() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int64_t> *lhs_dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_LHS_DILATION);
  }
  ::flatbuffers::Vector<int64_t> *mutable_lhs_dilation() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_LHS_DILATION);
  }
  const ::flatbuffers::Vector<int64_t> *rhs_dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_RHS_DILATION);
  }
  ::flatbuffers::Vector<int64_t> *mutable_rhs_dilation() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_RHS_DILATION);
  }
  const ::flatbuffers::Vector<uint8_t> *window_reversal() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_WINDOW_REVERSAL);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_window_reversal() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_WINDOW_REVERSAL);
  }
  int64_t input_batch_dimension() const {
    return GetField<int64_t>(VT_INPUT_BATCH_DIMENSION, 0);
  }
  bool mutate_input_batch_dimension(int64_t _input_batch_dimension = 0) {
    return SetField<int64_t>(VT_INPUT_BATCH_DIMENSION, _input_batch_dimension, 0);
  }
  int64_t input_feature_dimension() const {
    return GetField<int64_t>(VT_INPUT_FEATURE_DIMENSION, 0);
  }
  bool mutate_input_feature_dimension(int64_t _input_feature_dimension = 0) {
    return SetField<int64_t>(VT_INPUT_FEATURE_DIMENSION, _input_feature_dimension, 0);
  }
  const ::flatbuffers::Vector<int64_t> *input_spatial_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INPUT_SPATIAL_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_input_spatial_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_INPUT_SPATIAL_DIMENSIONS);
  }
  int64_t kernel_input_feature_dimension() const {
    return GetField<int64_t>(VT_KERNEL_INPUT_FEATURE_DIMENSION, 0);
  }
  bool mutate_kernel_input_feature_dimension(int64_t _kernel_input_feature_dimension = 0) {
    return SetField<int64_t>(VT_KERNEL_INPUT_FEATURE_DIMENSION, _kernel_input_feature_dimension, 0);
  }
  int64_t kernel_output_feature_dimension() const {
    return GetField<int64_t>(VT_KERNEL_OUTPUT_FEATURE_DIMENSION, 0);
  }
  bool mutate_kernel_output_feature_dimension(int64_t _kernel_output_feature_dimension = 0) {
    return SetField<int64_t>(VT_KERNEL_OUTPUT_FEATURE_DIMENSION, _kernel_output_feature_dimension, 0);
  }
  const ::flatbuffers::Vector<int64_t> *kernel_spatial_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_KERNEL_SPATIAL_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_kernel_spatial_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_KERNEL_SPATIAL_DIMENSIONS);
  }
  int64_t output_batch_dimension() const {
    return GetField<int64_t>(VT_OUTPUT_BATCH_DIMENSION, 0);
  }
  bool mutate_output_batch_dimension(int64_t _output_batch_dimension = 0) {
    return SetField<int64_t>(VT_OUTPUT_BATCH_DIMENSION, _output_batch_dimension, 0);
  }
  int64_t output_feature_dimension() const {
    return GetField<int64_t>(VT_OUTPUT_FEATURE_DIMENSION, 0);
  }
  bool mutate_output_feature_dimension(int64_t _output_feature_dimension = 0) {
    return SetField<int64_t>(VT_OUTPUT_FEATURE_DIMENSION, _output_feature_dimension, 0);
  }
  const ::flatbuffers::Vector<int64_t> *output_spatial_dimensions() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_OUTPUT_SPATIAL_DIMENSIONS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_output_spatial_dimensions() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_OUTPUT_SPATIAL_DIMENSIONS);
  }
  int64_t feature_group_count() const {
    return GetField<int64_t>(VT_FEATURE_GROUP_COUNT, 0);
  }
  bool mutate_feature_group_count(int64_t _feature_group_count = 0) {
    return SetField<int64_t>(VT_FEATURE_GROUP_COUNT, _feature_group_count, 0);
  }
  int64_t batch_group_count() const {
    return GetField<int64_t>(VT_BATCH_GROUP_COUNT, 0);
  }
  bool mutate_batch_group_count(int64_t _batch_group_count = 0) {
    return SetField<int64_t>(VT_BATCH_GROUP_COUNT, _batch_group_count, 0);
  }
  const ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *precision_config() const {
    return GetPointer<const ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *>(VT_PRECISION_CONFIG);
  }
  ::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *mutable_precision_config() {
    return GetPointer<::flatbuffers::Vector<tflite::StablehloPrecisionConfig> *>(VT_PRECISION_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WINDOW_STRIDES) &&
           verifier.VerifyVector(window_strides()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_LHS_DILATION) &&
           verifier.VerifyVector(lhs_dilation()) &&
           VerifyOffset(verifier, VT_RHS_DILATION) &&
           verifier.VerifyVector(rhs_dilation()) &&
           VerifyOffset(verifier, VT_WINDOW_REVERSAL) &&
           verifier.VerifyVector(window_reversal()) &&
           VerifyField<int64_t>(verifier, VT_INPUT_BATCH_DIMENSION, 8) &&
           VerifyField<int64_t>(verifier, VT_INPUT_FEATURE_DIMENSION, 8) &&
           VerifyOffset(verifier, VT_INPUT_SPATIAL_DIMENSIONS) &&
           verifier.VerifyVector(input_spatial_dimensions()) &&
           VerifyField<int64_t>(verifier, VT_KERNEL_INPUT_FEATURE_DIMENSION, 8) &&
           VerifyField<int64_t>(verifier, VT_KERNEL_OUTPUT_FEATURE_DIMENSION, 8) &&
           VerifyOffset(verifier, VT_KERNEL_SPATIAL_DIMENSIONS) &&
           verifier.VerifyVector(kernel_spatial_dimensions()) &&
           VerifyField<int64_t>(verifier, VT_OUTPUT_BATCH_DIMENSION, 8) &&
           VerifyField<int64_t>(verifier, VT_OUTPUT_FEATURE_DIMENSION, 8) &&
           VerifyOffset(verifier, VT_OUTPUT_SPATIAL_DIMENSIONS) &&
           verifier.VerifyVector(output_spatial_dimensions()) &&
           VerifyField<int64_t>(verifier, VT_FEATURE_GROUP_COUNT, 8) &&
           VerifyField<int64_t>(verifier, VT_BATCH_GROUP_COUNT, 8) &&
           VerifyOffset(verifier, VT_PRECISION_CONFIG) &&
           verifier.VerifyVector(precision_config()) &&
           verifier.EndTable();
  }
};

struct StablehloConvolutionOptionsBuilder {
  typedef StablehloConvolutionOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_window_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_STRIDES, window_strides);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_PADDING, padding);
  }
  void add_lhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_dilation) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_LHS_DILATION, lhs_dilation);
  }
  void add_rhs_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_dilation) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_RHS_DILATION, rhs_dilation);
  }
  void add_window_reversal(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> window_reversal) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_WINDOW_REVERSAL, window_reversal);
  }
  void add_input_batch_dimension(int64_t input_batch_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_BATCH_DIMENSION, input_batch_dimension, 0);
  }
  void add_input_feature_dimension(int64_t input_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_INPUT_FEATURE_DIMENSION, input_feature_dimension, 0);
  }
  void add_input_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> input_spatial_dimensions) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_INPUT_SPATIAL_DIMENSIONS, input_spatial_dimensions);
  }
  void add_kernel_input_feature_dimension(int64_t kernel_input_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_KERNEL_INPUT_FEATURE_DIMENSION, kernel_input_feature_dimension, 0);
  }
  void add_kernel_output_feature_dimension(int64_t kernel_output_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_KERNEL_OUTPUT_FEATURE_DIMENSION, kernel_output_feature_dimension, 0);
  }
  void add_kernel_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> kernel_spatial_dimensions) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_KERNEL_SPATIAL_DIMENSIONS, kernel_spatial_dimensions);
  }
  void add_output_batch_dimension(int64_t output_batch_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_OUTPUT_BATCH_DIMENSION, output_batch_dimension, 0);
  }
  void add_output_feature_dimension(int64_t output_feature_dimension) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_OUTPUT_FEATURE_DIMENSION, output_feature_dimension, 0);
  }
  void add_output_spatial_dimensions(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> output_spatial_dimensions) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_OUTPUT_SPATIAL_DIMENSIONS, output_spatial_dimensions);
  }
  void add_feature_group_count(int64_t feature_group_count) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_FEATURE_GROUP_COUNT, feature_group_count, 0);
  }
  void add_batch_group_count(int64_t batch_group_count) {
    fbb_.AddElement<int64_t>(StablehloConvolutionOptions::VT_BATCH_GROUP_COUNT, batch_group_count, 0);
  }
  void add_precision_config(::flatbuffers::Offset<::flatbuffers::Vector<tflite::StablehloPrecisionConfig>> precision_config) {
    fbb_.AddOffset(StablehloConvolutionOptions::VT_PRECISION_CONFIG, precision_config);
  }
  explicit StablehloConvolutionOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloConvolutionOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloConvolutionOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> window_strides = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> lhs_dilation = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> rhs_dilation = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> window_reversal = 0,
    int64_t input_batch_dimension = 0,
    int64_t input_feature_dimension = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> input_spatial_dimensions = 0,
    int64_t kernel_input_feature_dimension = 0,
    int64_t kernel_output_feature_dimension = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> kernel_spatial_dimensions = 0,
    int64_t output_batch_dimension = 0,
    int64_t output_feature_dimension = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> output_spatial_dimensions = 0,
    int64_t feature_group_count = 0,
    int64_t batch_group_count = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<tflite::StablehloPrecisionConfig>> precision_config = 0) {
  StablehloConvolutionOptionsBuilder builder_(_fbb);
  builder_.add_batch_group_count(batch_group_count);
  builder_.add_feature_group_count(feature_group_count);
  builder_.add_output_feature_dimension(output_feature_dimension);
  builder_.add_output_batch_dimension(output_batch_dimension);
  builder_.add_kernel_output_feature_dimension(kernel_output_feature_dimension);
  builder_.add_kernel_input_feature_dimension(kernel_input_feature_dimension);
  builder_.add_input_feature_dimension(input_feature_dimension);
  builder_.add_input_batch_dimension(input_batch_dimension);
  builder_.add_precision_config(precision_config);
  builder_.add_output_spatial_dimensions(output_spatial_dimensions);
  builder_.add_kernel_spatial_dimensions(kernel_spatial_dimensions);
  builder_.add_input_spatial_dimensions(input_spatial_dimensions);
  builder_.add_window_reversal(window_reversal);
  builder_.add_rhs_dilation(rhs_dilation);
  builder_.add_lhs_dilation(lhs_dilation);
  builder_.add_padding(padding);
  builder_.add_window_strides(window_strides);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloConvolutionOptions> CreateStablehloConvolutionOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *window_strides = nullptr,
    const std::vector<int64_t> *padding = nullptr,
    const std::vector<int64_t> *lhs_dilation = nullptr,
    const std::vector<int64_t> *rhs_dilation = nullptr,
    const std::vector<uint8_t> *window_reversal = nullptr,
    int64_t input_batch_dimension = 0,
    int64_t input_feature_dimension = 0,
    const std::vector<int64_t> *input_spatial_dimensions = nullptr,
    int64_t kernel_input_feature_dimension = 0,
    int64_t kernel_output_feature_dimension = 0,
    const std::vector<int64_t> *kernel_spatial_dimensions = nullptr,
    int64_t output_batch_dimension = 0,
    int64_t output_feature_dimension = 0,
    const std::vector<int64_t> *output_spatial_dimensions = nullptr,
    int64_t feature_group_count = 0,
    int64_t batch_group_count = 0,
    const std::vector<tflite::StablehloPrecisionConfig> *precision_config = nullptr) {
  auto window_strides__ = window_strides ? _fbb.CreateVector<int64_t>(*window_strides) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int64_t>(*padding) : 0;
  auto lhs_dilation__ = lhs_dilation ? _fbb.CreateVector<int64_t>(*lhs_dilation) : 0;
  auto rhs_dilation__ = rhs_dilation ? _fbb.CreateVector<int64_t>(*rhs_dilation) : 0;
  auto window_reversal__ = window_reversal ? _fbb.CreateVector<uint8_t>(*window_reversal) : 0;
  auto input_spatial_dimensions__ = input_spatial_dimensions ? _fbb.CreateVector<int64_t>(*input_spatial_dimensions) : 0;
  auto kernel_spatial_dimensions__ = kernel_spatial_dimensions ? _fbb.CreateVector<int64_t>(*kernel_spatial_dimensions) : 0;
  auto output_spatial_dimensions__ = output_spatial_dimensions ? _fbb.CreateVector<int64_t>(*output_spatial_dimensions) : 0;
  auto precision_config__ = precision_config ? _fbb.CreateVector<tflite::StablehloPrecisionConfig>(*precision_config) : 0;
  return tflite::CreateStablehloConvolutionOptions(
      _fbb,
      window_strides__,
      padding__,
      lhs_dilation__,
      rhs_dilation__,
      window_reversal__,
      input_batch_dimension,
      input_feature_dimension,
      input_spatial_dimensions__,
      kernel_input_feature_dimension,
      kernel_output_feature_dimension,
      kernel_spatial_dimensions__,
      output_batch_dimension,
      output_feature_dimension,
      output_spatial_dimensions__,
      feature_group_count,
      batch_group_count,
      precision_config__);
}

struct StablehloScatterOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloScatterOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloScatterOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INDICES_ARE_SORTED = 4,
    VT_UPDATE_WINDOW_DIMS = 6,
    VT_INSERTED_WINDOW_DIMS = 8,
    VT_SCATTER_DIMS_TO_OPERAND_DIMS = 10,
    VT_INDEX_VECTOR_DIM = 12,
    VT_UNIQUE_INDICES = 14,
    VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX = 16
  };
  bool indices_are_sorted() const {
    return GetField<uint8_t>(VT_INDICES_ARE_SORTED, 0) != 0;
  }
  bool mutate_indices_are_sorted(bool _indices_are_sorted = 0) {
    return SetField<uint8_t>(VT_INDICES_ARE_SORTED, static_cast<uint8_t>(_indices_are_sorted), 0);
  }
  const ::flatbuffers::Vector<int64_t> *update_window_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_UPDATE_WINDOW_DIMS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_update_window_dims() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_UPDATE_WINDOW_DIMS);
  }
  const ::flatbuffers::Vector<int64_t> *inserted_window_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INSERTED_WINDOW_DIMS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_inserted_window_dims() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_INSERTED_WINDOW_DIMS);
  }
  const ::flatbuffers::Vector<int64_t> *scatter_dims_to_operand_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS);
  }
  ::flatbuffers::Vector<int64_t> *mutable_scatter_dims_to_operand_dims() {
    return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_SCATTER_DIMS_TO_OPERAND_DIMS);
  }
  int64_t index_vector_dim() const {
    return GetField<int64_t>(VT_INDEX_VECTOR_DIM, 0);
  }
  bool mutate_index_vector_dim(int64_t _index_vector_dim = 0) {
    return SetField<int64_t>(VT_INDEX_VECTOR_DIM, _index_vector_dim, 0);
  }
  bool unique_indices() const {
    return GetField<uint8_t>(VT_UNIQUE_INDICES, 0) != 0;
  }
  bool mutate_unique_indices(bool _unique_indices = 0) {
    return SetField<uint8_t>(VT_UNIQUE_INDICES, static_cast<uint8_t>(_unique_indices), 0);
  }
  int32_t update_computation_subgraph_index() const {
    return GetField<int32_t>(VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, 0);
  }
  bool mutate_update_computation_subgraph_index(int32_t _update_computation_subgraph_index = 0) {
    return SetField<int32_t>(VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, _update_computation_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_INDICES_ARE_SORTED, 1) &&
           VerifyOffset(verifier, VT_UPDATE_WINDOW_DIMS) &&
           verifier.VerifyVector(update_window_dims()) &&
           VerifyOffset(verifier, VT_INSERTED_WINDOW_DIMS) &&
           verifier.VerifyVector(inserted_window_dims()) &&
           VerifyOffset(verifier, VT_SCATTER_DIMS_TO_OPERAND_DIMS) &&
           verifier.VerifyVector(scatter_dims_to_operand_dims()) &&
           VerifyField<int64_t>(verifier, VT_INDEX_VECTOR_DIM, 8) &&
           VerifyField<uint8_t>(verifier, VT_UNIQUE_INDICES, 1) &&
           VerifyField<int32_t>(verifier, VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct StablehloScatterOptionsBuilder {
  typedef StablehloScatterOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_indices_are_sorted(bool indices_are_sorted) {
    fbb_.AddElement<uint8_t>(StablehloScatterOptions::VT_INDICES_ARE_SORTED, static_cast<uint8_t>(indices_are_sorted), 0);
  }
  void add_update_window_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> update_window_dims) {
    fbb_.AddOffset(StablehloScatterOptions::VT_UPDATE_WINDOW_DIMS, update_window_dims);
  }
  void add_inserted_window_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> inserted_window_dims) {
    fbb_.AddOffset(StablehloScatterOptions::VT_INSERTED_WINDOW_DIMS, inserted_window_dims);
  }
  void add_scatter_dims_to_operand_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> scatter_dims_to_operand_dims) {
    fbb_.AddOffset(StablehloScatterOptions::VT_SCATTER_DIMS_TO_OPERAND_DIMS, scatter_dims_to_operand_dims);
  }
  void add_index_vector_dim(int64_t index_vector_dim) {
    fbb_.AddElement<int64_t>(StablehloScatterOptions::VT_INDEX_VECTOR_DIM, index_vector_dim, 0);
  }
  void add_unique_indices(bool unique_indices) {
    fbb_.AddElement<uint8_t>(StablehloScatterOptions::VT_UNIQUE_INDICES, static_cast<uint8_t>(unique_indices), 0);
  }
  void add_update_computation_subgraph_index(int32_t update_computation_subgraph_index) {
    fbb_.AddElement<int32_t>(StablehloScatterOptions::VT_UPDATE_COMPUTATION_SUBGRAPH_INDEX, update_computation_subgraph_index, 0);
  }
  explicit StablehloScatterOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloScatterOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloScatterOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool indices_are_sorted = false,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> update_window_dims = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> inserted_window_dims = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> scatter_dims_to_operand_dims = 0,
    int64_t index_vector_dim = 0,
    bool unique_indices = false,
    int32_t update_computation_subgraph_index = 0) {
  StablehloScatterOptionsBuilder builder_(_fbb);
  builder_.add_index_vector_dim(index_vector_dim);
  builder_.add_update_computation_subgraph_index(update_computation_subgraph_index);
  builder_.add_scatter_dims_to_operand_dims(scatter_dims_to_operand_dims);
  builder_.add_inserted_window_dims(inserted_window_dims);
  builder_.add_update_window_dims(update_window_dims);
  builder_.add_unique_indices(unique_indices);
  builder_.add_indices_are_sorted(indices_are_sorted);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StablehloScatterOptions> CreateStablehloScatterOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool indices_are_sorted = false,
    const std::vector<int64_t> *update_window_dims = nullptr,
    const std::vector<int64_t> *inserted_window_dims = nullptr,
    const std::vector<int64_t> *scatter_dims_to_operand_dims = nullptr,
    int64_t index_vector_dim = 0,
    bool unique_indices = false,
    int32_t update_computation_subgraph_index = 0) {
  auto update_window_dims__ = update_window_dims ? _fbb.CreateVector<int64_t>(*update_window_dims) : 0;
  auto inserted_window_dims__ = inserted_window_dims ? _fbb.CreateVector<int64_t>(*inserted_window_dims) : 0;
  auto scatter_dims_to_operand_dims__ = scatter_dims_to_operand_dims ? _fbb.CreateVector<int64_t>(*scatter_dims_to_operand_dims) : 0;
  return tflite::CreateStablehloScatterOptions(
      _fbb,
      indices_are_sorted,
      update_window_dims__,
      inserted_window_dims__,
      scatter_dims_to_operand_dims__,
      index_vector_dim,
      unique_indices,
      update_computation_subgraph_index);
}

struct StablehloRngBitGeneratorOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloRngBitGeneratorOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloRngBitGeneratorOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ALGORITHM = 4
  };
  tflite::RngAlgorithm algorithm() const {
    return static_cast<tflite::RngAlgorithm>(GetField<int8_t>(VT_ALGORITHM, 0));
  }
  bool mutate_algorithm(tflite::RngAlgorithm _algorithm = static_cast<tflite::RngAlgorithm>(0)) {
    return SetField<int8_t>(VT_ALGORITHM, static_cast<int8_t>(_algorithm), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_ALGORITHM, 1) &&
           verifier.EndTable();
  }
};

struct StablehloRngBitGeneratorOptionsBuilder {
  typedef StablehloRngBitGeneratorOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_algorithm(tflite::RngAlgorithm algorithm) {
    fbb_.AddElement<int8_t>(StablehloRngBitGeneratorOptions::VT_ALGORITHM, static_cast<int8_t>(algorithm), 0);
  }
  explicit StablehloRngBitGeneratorOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloRngBitGeneratorOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloRngBitGeneratorOptions> CreateStablehloRngBitGeneratorOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::RngAlgorithm algorithm = tflite::RngAlgorithm::DEFAULT) {
  StablehloRngBitGeneratorOptionsBuilder builder_(_fbb);
  builder_.add_algorithm(algorithm);
  return builder_.Finish();
}

struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Conv2DOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Conv2DOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PADDING = 4,
    VT_STRIDE_W = 6,
    VT_STRIDE_H = 8,
    VT_FUSED_ACTIVATION_FUNCTION = 10,
    VT_DILATION_W_FACTOR = 12,
    VT_DILATION_H_FACTOR = 14,
    VT_QUANTIZED_BIAS_TYPE = 16
  };
  tflite::Padding padding() const {
    return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
  }
  bool mutate_padding(tflite::Padding _padding = static_cast<tflite::Padding>(0)) {
    return SetField<int8_t>(VT_PADDING, static_cast<int8_t>(_padding), 0);
  }
  int32_t stride_w() const {
    return GetField<int32_t>(VT_STRIDE_W, 0);
  }
  bool mutate_stride_w(int32_t _stride_w = 0) {
    return SetField<int32_t>(VT_STRIDE_W, _stride_w, 0);
  }
  int32_t stride_h() const {
    return GetField<int32_t>(VT_STRIDE_H, 0);
  }
  bool mutate_stride_h(int32_t _stride_h = 0) {
    return SetField<int32_t>(VT_STRIDE_H, _stride_h, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  int32_t dilation_w_factor() const {
    return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
  }
  bool mutate_dilation_w_factor(int32_t _dilation_w_factor = 1) {
    return SetField<int32_t>(VT_DILATION_W_FACTOR, _dilation_w_factor, 1);
  }
  int32_t dilation_h_factor() const {
    return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
  }
  bool mutate_dilation_h_factor(int32_t _dilation_h_factor = 1) {
    return SetField<int32_t>(VT_DILATION_H_FACTOR, _dilation_h_factor, 1);
  }
  tflite::TensorType quantized_bias_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
  }
  bool mutate_quantized_bias_type(tflite::TensorType _quantized_bias_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(_quantized_bias_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
           VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
           VerifyField<int8_t>(verifier, VT_QUANTIZED_BIAS_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct Conv2DOptionsBuilder {
  typedef Conv2DOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_padding(tflite::Padding padding) {
    fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
  }
  void add_stride_w(int32_t stride_w) {
    fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
  }
  void add_stride_h(int32_t stride_h) {
    fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_dilation_w_factor(int32_t dilation_w_factor) {
    fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
  }
  void add_dilation_h_factor(int32_t dilation_h_factor) {
    fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
  }
  void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
    fbb_.AddElement<int8_t>(Conv2DOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
  }
  explicit Conv2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Conv2DOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Conv2DOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Padding padding = tflite::Padding::SAME,
    int32_t stride_w = 0,
    int32_t stride_h = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    int32_t dilation_w_factor = 1,
    int32_t dilation_h_factor = 1,
    tflite::TensorType quantized_bias_type = tflite::TensorType::FLOAT32) {
  Conv2DOptionsBuilder builder_(_fbb);
  builder_.add_dilation_h_factor(dilation_h_factor);
  builder_.add_dilation_w_factor(dilation_w_factor);
  builder_.add_stride_h(stride_h);
  builder_.add_stride_w(stride_w);
  builder_.add_quantized_bias_type(quantized_bias_type);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_padding(padding);
  return builder_.Finish();
}

struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Conv3DOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Conv3DOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PADDING = 4,
    VT_STRIDE_D = 6,
    VT_STRIDE_W = 8,
    VT_STRIDE_H = 10,
    VT_FUSED_ACTIVATION_FUNCTION = 12,
    VT_DILATION_D_FACTOR = 14,
    VT_DILATION_W_FACTOR = 16,
    VT_DILATION_H_FACTOR = 18
  };
  tflite::Padding padding() const {
    return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
  }
  bool mutate_padding(tflite::Padding _padding = static_cast<tflite::Padding>(0)) {
    return SetField<int8_t>(VT_PADDING, static_cast<int8_t>(_padding), 0);
  }
  int32_t stride_d() const {
    return GetField<int32_t>(VT_STRIDE_D, 0);
  }
  bool mutate_stride_d(int32_t _stride_d = 0) {
    return SetField<int32_t>(VT_STRIDE_D, _stride_d, 0);
  }
  int32_t stride_w() const {
    return GetField<int32_t>(VT_STRIDE_W, 0);
  }
  bool mutate_stride_w(int32_t _stride_w = 0) {
    return SetField<int32_t>(VT_STRIDE_W, _stride_w, 0);
  }
  int32_t stride_h() const {
    return GetField<int32_t>(VT_STRIDE_H, 0);
  }
  bool mutate_stride_h(int32_t _stride_h = 0) {
    return SetField<int32_t>(VT_STRIDE_H, _stride_h, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  int32_t dilation_d_factor() const {
    return GetField<int32_t>(VT_DILATION_D_FACTOR, 1);
  }
  bool mutate_dilation_d_factor(int32_t _dilation_d_factor = 1) {
    return SetField<int32_t>(VT_DILATION_D_FACTOR, _dilation_d_factor, 1);
  }
  int32_t dilation_w_factor() const {
    return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
  }
  bool mutate_dilation_w_factor(int32_t _dilation_w_factor = 1) {
    return SetField<int32_t>(VT_DILATION_W_FACTOR, _dilation_w_factor, 1);
  }
  int32_t dilation_h_factor() const {
    return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
  }
  bool mutate_dilation_h_factor(int32_t _dilation_h_factor = 1) {
    return SetField<int32_t>(VT_DILATION_H_FACTOR, _dilation_h_factor, 1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_D, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR, 4) &&
           VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
           VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
           verifier.EndTable();
  }
};

struct Conv3DOptionsBuilder {
  typedef Conv3DOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_padding(tflite::Padding padding) {
    fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
  }
  void add_stride_d(int32_t stride_d) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, 0);
  }
  void add_stride_w(int32_t stride_w) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, 0);
  }
  void add_stride_h(int32_t stride_h) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_dilation_d_factor(int32_t dilation_d_factor) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, 1);
  }
  void add_dilation_w_factor(int32_t dilation_w_factor) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
  }
  void add_dilation_h_factor(int32_t dilation_h_factor) {
    fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
  }
  explicit Conv3DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Conv3DOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Conv3DOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Padding padding = tflite::Padding::SAME,
    int32_t stride_d = 0,
    int32_t stride_w = 0,
    int32_t stride_h = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    int32_t dilation_d_factor = 1,
    int32_t dilation_w_factor = 1,
    int32_t dilation_h_factor = 1) {
  Conv3DOptionsBuilder builder_(_fbb);
  builder_.add_dilation_h_factor(dilation_h_factor);
  builder_.add_dilation_w_factor(dilation_w_factor);
  builder_.add_dilation_d_factor(dilation_d_factor);
  builder_.add_stride_h(stride_h);
  builder_.add_stride_w(stride_w);
  builder_.add_stride_d(stride_d);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_padding(padding);
  return builder_.Finish();
}

struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Pool2DOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Pool2DOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PADDING = 4,
    VT_STRIDE_W = 6,
    VT_STRIDE_H = 8,
    VT_FILTER_WIDTH = 10,
    VT_FILTER_HEIGHT = 12,
    VT_FUSED_ACTIVATION_FUNCTION = 14
  };
  tflite::Padding padding() const {
    return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
  }
  bool mutate_padding(tflite::Padding _padding = static_cast<tflite::Padding>(0)) {
    return SetField<int8_t>(VT_PADDING, static_cast<int8_t>(_padding), 0);
  }
  int32_t stride_w() const {
    return GetField<int32_t>(VT_STRIDE_W, 0);
  }
  bool mutate_stride_w(int32_t _stride_w = 0) {
    return SetField<int32_t>(VT_STRIDE_W, _stride_w, 0);
  }
  int32_t stride_h() const {
    return GetField<int32_t>(VT_STRIDE_H, 0);
  }
  bool mutate_stride_h(int32_t _stride_h = 0) {
    return SetField<int32_t>(VT_STRIDE_H, _stride_h, 0);
  }
  int32_t filter_width() const {
    return GetField<int32_t>(VT_FILTER_WIDTH, 0);
  }
  bool mutate_filter_width(int32_t _filter_width = 0) {
    return SetField<int32_t>(VT_FILTER_WIDTH, _filter_width, 0);
  }
  int32_t filter_height() const {
    return GetField<int32_t>(VT_FILTER_HEIGHT, 0);
  }
  bool mutate_filter_height(int32_t _filter_height = 0) {
    return SetField<int32_t>(VT_FILTER_HEIGHT, _filter_height, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
           VerifyField<int32_t>(verifier, VT_FILTER_WIDTH, 4) &&
           VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           verifier.EndTable();
  }
};

struct Pool2DOptionsBuilder {
  typedef Pool2DOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_padding(tflite::Padding padding) {
    fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
  }
  void add_stride_w(int32_t stride_w) {
    fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
  }
  void add_stride_h(int32_t stride_h) {
    fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
  }
  void add_filter_width(int32_t filter_width) {
    fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
  }
  void add_filter_height(int32_t filter_height) {
    fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  explicit Pool2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Pool2DOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Pool2DOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Padding padding = tflite::Padding::SAME,
    int32_t stride_w = 0,
    int32_t stride_h = 0,
    int32_t filter_width = 0,
    int32_t filter_height = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE) {
  Pool2DOptionsBuilder builder_(_fbb);
  builder_.add_filter_height(filter_height);
  builder_.add_filter_width(filter_width);
  builder_.add_stride_h(stride_h);
  builder_.add_stride_w(stride_w);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_padding(padding);
  return builder_.Finish();
}

struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DepthwiseConv2DOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DepthwiseConv2DOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PADDING = 4,
    VT_STRIDE_W = 6,
    VT_STRIDE_H = 8,
    VT_DEPTH_MULTIPLIER = 10,
    VT_FUSED_ACTIVATION_FUNCTION = 12,
    VT_DILATION_W_FACTOR = 14,
    VT_DILATION_H_FACTOR = 16
  };
  tflite::Padding padding() const {
    return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
  }
  bool mutate_padding(tflite::Padding _padding = static_cast<tflite::Padding>(0)) {
    return SetField<int8_t>(VT_PADDING, static_cast<int8_t>(_padding), 0);
  }
  int32_t stride_w() const {
    return GetField<int32_t>(VT_STRIDE_W, 0);
  }
  bool mutate_stride_w(int32_t _stride_w = 0) {
    return SetField<int32_t>(VT_STRIDE_W, _stride_w, 0);
  }
  int32_t stride_h() const {
    return GetField<int32_t>(VT_STRIDE_H, 0);
  }
  bool mutate_stride_h(int32_t _stride_h = 0) {
    return SetField<int32_t>(VT_STRIDE_H, _stride_h, 0);
  }
  int32_t depth_multiplier() const {
    return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0);
  }
  bool mutate_depth_multiplier(int32_t _depth_multiplier = 0) {
    return SetField<int32_t>(VT_DEPTH_MULTIPLIER, _depth_multiplier, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  int32_t dilation_w_factor() const {
    return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
  }
  bool mutate_dilation_w_factor(int32_t _dilation_w_factor = 1) {
    return SetField<int32_t>(VT_DILATION_W_FACTOR, _dilation_w_factor, 1);
  }
  int32_t dilation_h_factor() const {
    return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
  }
  bool mutate_dilation_h_factor(int32_t _dilation_h_factor = 1) {
    return SetField<int32_t>(VT_DILATION_H_FACTOR, _dilation_h_factor, 1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
           VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
           VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
           verifier.EndTable();
  }
};

struct DepthwiseConv2DOptionsBuilder {
  typedef DepthwiseConv2DOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_padding(tflite::Padding padding) {
    fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
  }
  void add_stride_w(int32_t stride_w) {
    fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
  }
  void add_stride_h(int32_t stride_h) {
    fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
  }
  void add_depth_multiplier(int32_t depth_multiplier) {
    fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_dilation_w_factor(int32_t dilation_w_factor) {
    fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
  }
  void add_dilation_h_factor(int32_t dilation_h_factor) {
    fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
  }
  explicit DepthwiseConv2DOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DepthwiseConv2DOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Padding padding = tflite::Padding::SAME,
    int32_t stride_w = 0,
    int32_t stride_h = 0,
    int32_t depth_multiplier = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    int32_t dilation_w_factor = 1,
    int32_t dilation_h_factor = 1) {
  DepthwiseConv2DOptionsBuilder builder_(_fbb);
  builder_.add_dilation_h_factor(dilation_h_factor);
  builder_.add_dilation_w_factor(dilation_w_factor);
  builder_.add_depth_multiplier(depth_multiplier);
  builder_.add_stride_h(stride_h);
  builder_.add_stride_w(stride_w);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_padding(padding);
  return builder_.Finish();
}

struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConcatEmbeddingsOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ConcatEmbeddingsOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM_CHANNELS = 4,
    VT_NUM_COLUMNS_PER_CHANNEL = 6,
    VT_EMBEDDING_DIM_PER_CHANNEL = 8
  };
  int32_t num_channels() const {
    return GetField<int32_t>(VT_NUM_CHANNELS, 0);
  }
  bool mutate_num_channels(int32_t _num_channels = 0) {
    return SetField<int32_t>(VT_NUM_CHANNELS, _num_channels, 0);
  }
  const ::flatbuffers::Vector<int32_t> *num_columns_per_channel() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
  }
  ::flatbuffers::Vector<int32_t> *mutable_num_columns_per_channel() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
  }
  const ::flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
  }
  ::flatbuffers::Vector<int32_t> *mutable_embedding_dim_per_channel() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NUM_CHANNELS, 4) &&
           VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
           verifier.VerifyVector(num_columns_per_channel()) &&
           VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
           verifier.VerifyVector(embedding_dim_per_channel()) &&
           verifier.EndTable();
  }
};

struct ConcatEmbeddingsOptionsBuilder {
  typedef ConcatEmbeddingsOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_num_channels(int32_t num_channels) {
    fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
  }
  void add_num_columns_per_channel(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> num_columns_per_channel) {
    fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
  }
  void add_embedding_dim_per_channel(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
    fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
  }
  explicit ConcatEmbeddingsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_channels = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) {
  ConcatEmbeddingsOptionsBuilder builder_(_fbb);
  builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
  builder_.add_num_columns_per_channel(num_columns_per_channel);
  builder_.add_num_channels(num_channels);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_channels = 0,
    const std::vector<int32_t> *num_columns_per_channel = nullptr,
    const std::vector<int32_t> *embedding_dim_per_channel = nullptr) {
  auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
  auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
  return tflite::CreateConcatEmbeddingsOptions(
      _fbb,
      num_channels,
      num_columns_per_channel__,
      embedding_dim_per_channel__);
}

struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LSHProjectionOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LSHProjectionOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4
  };
  tflite::LSHProjectionType type() const {
    return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
  }
  bool mutate_type(tflite::LSHProjectionType _type = static_cast<tflite::LSHProjectionType>(0)) {
    return SetField<int8_t>(VT_TYPE, static_cast<int8_t>(_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct LSHProjectionOptionsBuilder {
  typedef LSHProjectionOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tflite::LSHProjectionType type) {
    fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
  }
  explicit LSHProjectionOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LSHProjectionOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LSHProjectionOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::LSHProjectionType type = tflite::LSHProjectionType::UNKNOWN) {
  LSHProjectionOptionsBuilder builder_(_fbb);
  builder_.add_type(type);
  return builder_.Finish();
}

struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SVDFOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SVDFOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RANK = 4,
    VT_FUSED_ACTIVATION_FUNCTION = 6,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
  };
  int32_t rank() const {
    return GetField<int32_t>(VT_RANK, 0);
  }
  bool mutate_rank(int32_t _rank = 0) {
    return SetField<int32_t>(VT_RANK, _rank, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_RANK, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct SVDFOptionsBuilder {
  typedef SVDFOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_rank(int32_t rank) {
    fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit SVDFOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SVDFOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SVDFOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t rank = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool asymmetric_quantize_inputs = false) {
  SVDFOptionsBuilder builder_(_fbb);
  builder_.add_rank(rank);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct RNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RNNOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RNNOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct RNNOptionsBuilder {
  typedef RNNOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit RNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RNNOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RNNOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RNNOptions> CreateRNNOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool asymmetric_quantize_inputs = false) {
  RNNOptionsBuilder builder_(_fbb);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SequenceRNNOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SequenceRNNOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TIME_MAJOR = 4,
    VT_FUSED_ACTIVATION_FUNCTION = 6,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
  };
  bool time_major() const {
    return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
  }
  bool mutate_time_major(bool _time_major = 0) {
    return SetField<uint8_t>(VT_TIME_MAJOR, static_cast<uint8_t>(_time_major), 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct SequenceRNNOptionsBuilder {
  typedef SequenceRNNOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_time_major(bool time_major) {
    fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit SequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SequenceRNNOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SequenceRNNOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool time_major = false,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool asymmetric_quantize_inputs = false) {
  SequenceRNNOptionsBuilder builder_(_fbb);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_time_major(time_major);
  return builder_.Finish();
}

struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BidirectionalSequenceRNNOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BidirectionalSequenceRNNOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TIME_MAJOR = 4,
    VT_FUSED_ACTIVATION_FUNCTION = 6,
    VT_MERGE_OUTPUTS = 8,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
  };
  bool time_major() const {
    return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
  }
  bool mutate_time_major(bool _time_major = 0) {
    return SetField<uint8_t>(VT_TIME_MAJOR, static_cast<uint8_t>(_time_major), 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool merge_outputs() const {
    return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
  }
  bool mutate_merge_outputs(bool _merge_outputs = 0) {
    return SetField<uint8_t>(VT_MERGE_OUTPUTS, static_cast<uint8_t>(_merge_outputs), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct BidirectionalSequenceRNNOptionsBuilder {
  typedef BidirectionalSequenceRNNOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_time_major(bool time_major) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_merge_outputs(bool merge_outputs) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit BidirectionalSequenceRNNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool time_major = false,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool merge_outputs = false,
    bool asymmetric_quantize_inputs = false) {
  BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_merge_outputs(merge_outputs);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_time_major(time_major);
  return builder_.Finish();
}

struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FullyConnectedOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FullyConnectedOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_WEIGHTS_FORMAT = 6,
    VT_KEEP_NUM_DIMS = 8,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 10,
    VT_QUANTIZED_BIAS_TYPE = 12
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  tflite::FullyConnectedOptionsWeightsFormat weights_format() const {
    return static_cast<tflite::FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
  }
  bool mutate_weights_format(tflite::FullyConnectedOptionsWeightsFormat _weights_format = static_cast<tflite::FullyConnectedOptionsWeightsFormat>(0)) {
    return SetField<int8_t>(VT_WEIGHTS_FORMAT, static_cast<int8_t>(_weights_format), 0);
  }
  bool keep_num_dims() const {
    return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0;
  }
  bool mutate_keep_num_dims(bool _keep_num_dims = 0) {
    return SetField<uint8_t>(VT_KEEP_NUM_DIMS, static_cast<uint8_t>(_keep_num_dims), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  tflite::TensorType quantized_bias_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
  }
  bool mutate_quantized_bias_type(tflite::TensorType _quantized_bias_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(_quantized_bias_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT, 1) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           VerifyField<int8_t>(verifier, VT_QUANTIZED_BIAS_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct FullyConnectedOptionsBuilder {
  typedef FullyConnectedOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_weights_format(tflite::FullyConnectedOptionsWeightsFormat weights_format) {
    fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), 0);
  }
  void add_keep_num_dims(bool keep_num_dims) {
    fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
    fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
  }
  explicit FullyConnectedOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FullyConnectedOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FullyConnectedOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat::DEFAULT,
    bool keep_num_dims = false,
    bool asymmetric_quantize_inputs = false,
    tflite::TensorType quantized_bias_type = tflite::TensorType::FLOAT32) {
  FullyConnectedOptionsBuilder builder_(_fbb);
  builder_.add_quantized_bias_type(quantized_bias_type);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_keep_num_dims(keep_num_dims);
  builder_.add_weights_format(weights_format);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SoftmaxOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SoftmaxOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BETA = 4
  };
  float beta() const {
    return GetField<float>(VT_BETA, 0.0f);
  }
  bool mutate_beta(float _beta = 0.0f) {
    return SetField<float>(VT_BETA, _beta, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_BETA, 4) &&
           verifier.EndTable();
  }
};

struct SoftmaxOptionsBuilder {
  typedef SoftmaxOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_beta(float beta) {
    fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
  }
  explicit SoftmaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SoftmaxOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SoftmaxOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float beta = 0.0f) {
  SoftmaxOptionsBuilder builder_(_fbb);
  builder_.add_beta(beta);
  return builder_.Finish();
}

struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConcatenationOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ConcatenationOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_AXIS = 4,
    VT_FUSED_ACTIVATION_FUNCTION = 6
  };
  int32_t axis() const {
    return GetField<int32_t>(VT_AXIS, 0);
  }
  bool mutate_axis(int32_t _axis = 0) {
    return SetField<int32_t>(VT_AXIS, _axis, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           verifier.EndTable();
  }
};

struct ConcatenationOptionsBuilder {
  typedef ConcatenationOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  explicit ConcatenationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConcatenationOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConcatenationOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t axis = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE) {
  ConcatenationOptionsBuilder builder_(_fbb);
  builder_.add_axis(axis);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct AddOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AddOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AddOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_POT_SCALE_INT16 = 6
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool pot_scale_int16() const {
    return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
  }
  bool mutate_pot_scale_int16(bool _pot_scale_int16 = 1) {
    return SetField<uint8_t>(VT_POT_SCALE_INT16, static_cast<uint8_t>(_pot_scale_int16), 1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, 1) &&
           verifier.EndTable();
  }
};

struct AddOptionsBuilder {
  typedef AddOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_pot_scale_int16(bool pot_scale_int16) {
    fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
  }
  explicit AddOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AddOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AddOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<AddOptions> CreateAddOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool pot_scale_int16 = true) {
  AddOptionsBuilder builder_(_fbb);
  builder_.add_pot_scale_int16(pot_scale_int16);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct MulOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MulOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MulOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           verifier.EndTable();
  }
};

struct MulOptionsBuilder {
  typedef MulOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  explicit MulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MulOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MulOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MulOptions> CreateMulOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE) {
  MulOptionsBuilder builder_(_fbb);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef L2NormOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return L2NormOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           verifier.EndTable();
  }
};

struct L2NormOptionsBuilder {
  typedef L2NormOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  explicit L2NormOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<L2NormOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<L2NormOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE) {
  L2NormOptionsBuilder builder_(_fbb);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LocalResponseNormalizationOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LocalResponseNormalizationOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RADIUS = 4,
    VT_BIAS = 6,
    VT_ALPHA = 8,
    VT_BETA = 10
  };
  int32_t radius() const {
    return GetField<int32_t>(VT_RADIUS, 0);
  }
  bool mutate_radius(int32_t _radius = 0) {
    return SetField<int32_t>(VT_RADIUS, _radius, 0);
  }
  float bias() const {
    return GetField<float>(VT_BIAS, 0.0f);
  }
  bool mutate_bias(float _bias = 0.0f) {
    return SetField<float>(VT_BIAS, _bias, 0.0f);
  }
  float alpha() const {
    return GetField<float>(VT_ALPHA, 0.0f);
  }
  bool mutate_alpha(float _alpha = 0.0f) {
    return SetField<float>(VT_ALPHA, _alpha, 0.0f);
  }
  float beta() const {
    return GetField<float>(VT_BETA, 0.0f);
  }
  bool mutate_beta(float _beta = 0.0f) {
    return SetField<float>(VT_BETA, _beta, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_RADIUS, 4) &&
           VerifyField<float>(verifier, VT_BIAS, 4) &&
           VerifyField<float>(verifier, VT_ALPHA, 4) &&
           VerifyField<float>(verifier, VT_BETA, 4) &&
           verifier.EndTable();
  }
};

struct LocalResponseNormalizationOptionsBuilder {
  typedef LocalResponseNormalizationOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_radius(int32_t radius) {
    fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
  }
  void add_bias(float bias) {
    fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
  }
  void add_alpha(float alpha) {
    fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
  }
  void add_beta(float beta) {
    fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
  }
  explicit LocalResponseNormalizationOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t radius = 0,
    float bias = 0.0f,
    float alpha = 0.0f,
    float beta = 0.0f) {
  LocalResponseNormalizationOptionsBuilder builder_(_fbb);
  builder_.add_beta(beta);
  builder_.add_alpha(alpha);
  builder_.add_bias(bias);
  builder_.add_radius(radius);
  return builder_.Finish();
}

struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LSTMOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LSTMOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_CELL_CLIP = 6,
    VT_PROJ_CLIP = 8,
    VT_KERNEL_TYPE = 10,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  float cell_clip() const {
    return GetField<float>(VT_CELL_CLIP, 0.0f);
  }
  bool mutate_cell_clip(float _cell_clip = 0.0f) {
    return SetField<float>(VT_CELL_CLIP, _cell_clip, 0.0f);
  }
  float proj_clip() const {
    return GetField<float>(VT_PROJ_CLIP, 0.0f);
  }
  bool mutate_proj_clip(float _proj_clip = 0.0f) {
    return SetField<float>(VT_PROJ_CLIP, _proj_clip, 0.0f);
  }
  tflite::LSTMKernelType kernel_type() const {
    return static_cast<tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
  }
  bool mutate_kernel_type(tflite::LSTMKernelType _kernel_type = static_cast<tflite::LSTMKernelType>(0)) {
    return SetField<int8_t>(VT_KERNEL_TYPE, static_cast<int8_t>(_kernel_type), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
           VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
           VerifyField<int8_t>(verifier, VT_KERNEL_TYPE, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct LSTMOptionsBuilder {
  typedef LSTMOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_cell_clip(float cell_clip) {
    fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
  }
  void add_proj_clip(float proj_clip) {
    fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
  }
  void add_kernel_type(tflite::LSTMKernelType kernel_type) {
    fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit LSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LSTMOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LSTMOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    float cell_clip = 0.0f,
    float proj_clip = 0.0f,
    tflite::LSTMKernelType kernel_type = tflite::LSTMKernelType::FULL,
    bool asymmetric_quantize_inputs = false) {
  LSTMOptionsBuilder builder_(_fbb);
  builder_.add_proj_clip(proj_clip);
  builder_.add_cell_clip(cell_clip);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_kernel_type(kernel_type);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnidirectionalSequenceLSTMOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnidirectionalSequenceLSTMOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_CELL_CLIP = 6,
    VT_PROJ_CLIP = 8,
    VT_TIME_MAJOR = 10,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 12,
    VT_DIAGONAL_RECURRENT_TENSORS = 14
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  float cell_clip() const {
    return GetField<float>(VT_CELL_CLIP, 0.0f);
  }
  bool mutate_cell_clip(float _cell_clip = 0.0f) {
    return SetField<float>(VT_CELL_CLIP, _cell_clip, 0.0f);
  }
  float proj_clip() const {
    return GetField<float>(VT_PROJ_CLIP, 0.0f);
  }
  bool mutate_proj_clip(float _proj_clip = 0.0f) {
    return SetField<float>(VT_PROJ_CLIP, _proj_clip, 0.0f);
  }
  bool time_major() const {
    return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
  }
  bool mutate_time_major(bool _time_major = 0) {
    return SetField<uint8_t>(VT_TIME_MAJOR, static_cast<uint8_t>(_time_major), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool diagonal_recurrent_tensors() const {
    return GetField<uint8_t>(VT_DIAGONAL_RECURRENT_TENSORS, 0) != 0;
  }
  bool mutate_diagonal_recurrent_tensors(bool _diagonal_recurrent_tensors = 0) {
    return SetField<uint8_t>(VT_DIAGONAL_RECURRENT_TENSORS, static_cast<uint8_t>(_diagonal_recurrent_tensors), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
           VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
           VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           VerifyField<uint8_t>(verifier, VT_DIAGONAL_RECURRENT_TENSORS, 1) &&
           verifier.EndTable();
  }
};

struct UnidirectionalSequenceLSTMOptionsBuilder {
  typedef UnidirectionalSequenceLSTMOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_cell_clip(float cell_clip) {
    fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
  }
  void add_proj_clip(float proj_clip) {
    fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
  }
  void add_time_major(bool time_major) {
    fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  void add_diagonal_recurrent_tensors(bool diagonal_recurrent_tensors) {
    fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_DIAGONAL_RECURRENT_TENSORS, static_cast<uint8_t>(diagonal_recurrent_tensors), 0);
  }
  explicit UnidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    float cell_clip = 0.0f,
    float proj_clip = 0.0f,
    bool time_major = false,
    bool asymmetric_quantize_inputs = false,
    bool diagonal_recurrent_tensors = false) {
  UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
  builder_.add_proj_clip(proj_clip);
  builder_.add_cell_clip(cell_clip);
  builder_.add_diagonal_recurrent_tensors(diagonal_recurrent_tensors);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_time_major(time_major);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BidirectionalSequenceLSTMOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BidirectionalSequenceLSTMOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_CELL_CLIP = 6,
    VT_PROJ_CLIP = 8,
    VT_MERGE_OUTPUTS = 10,
    VT_TIME_MAJOR = 12,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  float cell_clip() const {
    return GetField<float>(VT_CELL_CLIP, 0.0f);
  }
  bool mutate_cell_clip(float _cell_clip = 0.0f) {
    return SetField<float>(VT_CELL_CLIP, _cell_clip, 0.0f);
  }
  float proj_clip() const {
    return GetField<float>(VT_PROJ_CLIP, 0.0f);
  }
  bool mutate_proj_clip(float _proj_clip = 0.0f) {
    return SetField<float>(VT_PROJ_CLIP, _proj_clip, 0.0f);
  }
  bool merge_outputs() const {
    return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
  }
  bool mutate_merge_outputs(bool _merge_outputs = 0) {
    return SetField<uint8_t>(VT_MERGE_OUTPUTS, static_cast<uint8_t>(_merge_outputs), 0);
  }
  bool time_major() const {
    return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0;
  }
  bool mutate_time_major(bool _time_major = 1) {
    return SetField<uint8_t>(VT_TIME_MAJOR, static_cast<uint8_t>(_time_major), 1);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
           VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
           VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, 1) &&
           VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct BidirectionalSequenceLSTMOptionsBuilder {
  typedef BidirectionalSequenceLSTMOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_cell_clip(float cell_clip) {
    fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
  }
  void add_proj_clip(float proj_clip) {
    fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
  }
  void add_merge_outputs(bool merge_outputs) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
  }
  void add_time_major(bool time_major) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 1);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit BidirectionalSequenceLSTMOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    float cell_clip = 0.0f,
    float proj_clip = 0.0f,
    bool merge_outputs = false,
    bool time_major = true,
    bool asymmetric_quantize_inputs = false) {
  BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
  builder_.add_proj_clip(proj_clip);
  builder_.add_cell_clip(cell_clip);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_time_major(time_major);
  builder_.add_merge_outputs(merge_outputs);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ResizeBilinearOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ResizeBilinearOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ALIGN_CORNERS = 8,
    VT_HALF_PIXEL_CENTERS = 10
  };
  bool align_corners() const {
    return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
  }
  bool mutate_align_corners(bool _align_corners = 0) {
    return SetField<uint8_t>(VT_ALIGN_CORNERS, static_cast<uint8_t>(_align_corners), 0);
  }
  bool half_pixel_centers() const {
    return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
  }
  bool mutate_half_pixel_centers(bool _half_pixel_centers = 0) {
    return SetField<uint8_t>(VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(_half_pixel_centers), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
           VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, 1) &&
           verifier.EndTable();
  }
};

struct ResizeBilinearOptionsBuilder {
  typedef ResizeBilinearOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_align_corners(bool align_corners) {
    fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
  }
  void add_half_pixel_centers(bool half_pixel_centers) {
    fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
  }
  explicit ResizeBilinearOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ResizeBilinearOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ResizeBilinearOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool align_corners = false,
    bool half_pixel_centers = false) {
  ResizeBilinearOptionsBuilder builder_(_fbb);
  builder_.add_half_pixel_centers(half_pixel_centers);
  builder_.add_align_corners(align_corners);
  return builder_.Finish();
}

struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ResizeNearestNeighborOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ResizeNearestNeighborOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ALIGN_CORNERS = 4,
    VT_HALF_PIXEL_CENTERS = 6
  };
  bool align_corners() const {
    return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
  }
  bool mutate_align_corners(bool _align_corners = 0) {
    return SetField<uint8_t>(VT_ALIGN_CORNERS, static_cast<uint8_t>(_align_corners), 0);
  }
  bool half_pixel_centers() const {
    return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
  }
  bool mutate_half_pixel_centers(bool _half_pixel_centers = 0) {
    return SetField<uint8_t>(VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(_half_pixel_centers), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
           VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, 1) &&
           verifier.EndTable();
  }
};

struct ResizeNearestNeighborOptionsBuilder {
  typedef ResizeNearestNeighborOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_align_corners(bool align_corners) {
    fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
  }
  void add_half_pixel_centers(bool half_pixel_centers) {
    fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
  }
  explicit ResizeNearestNeighborOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool align_corners = false,
    bool half_pixel_centers = false) {
  ResizeNearestNeighborOptionsBuilder builder_(_fbb);
  builder_.add_half_pixel_centers(half_pixel_centers);
  builder_.add_align_corners(align_corners);
  return builder_.Finish();
}

struct CallOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CallOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CallOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUBGRAPH = 4
  };
  uint32_t subgraph() const {
    return GetField<uint32_t>(VT_SUBGRAPH, 0);
  }
  bool mutate_subgraph(uint32_t _subgraph = 0) {
    return SetField<uint32_t>(VT_SUBGRAPH, _subgraph, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SUBGRAPH, 4) &&
           verifier.EndTable();
  }
};

struct CallOptionsBuilder {
  typedef CallOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_subgraph(uint32_t subgraph) {
    fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
  }
  explicit CallOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CallOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CallOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CallOptions> CreateCallOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t subgraph = 0) {
  CallOptionsBuilder builder_(_fbb);
  builder_.add_subgraph(subgraph);
  return builder_.Finish();
}

struct PadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PadOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PadOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct PadOptionsBuilder {
  typedef PadOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit PadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PadOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PadOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PadOptions> CreatePadOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  PadOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct PadV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PadV2OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PadV2OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct PadV2OptionsBuilder {
  typedef PadV2Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit PadV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PadV2Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PadV2Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PadV2Options> CreatePadV2Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  PadV2OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReshapeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReshapeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NEW_SHAPE = 4
  };
  const ::flatbuffers::Vector<int32_t> *new_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
  }
  ::flatbuffers::Vector<int32_t> *mutable_new_shape() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NEW_SHAPE) &&
           verifier.VerifyVector(new_shape()) &&
           verifier.EndTable();
  }
};

struct ReshapeOptionsBuilder {
  typedef ReshapeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_new_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> new_shape) {
    fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
  }
  explicit ReshapeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReshapeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReshapeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> new_shape = 0) {
  ReshapeOptionsBuilder builder_(_fbb);
  builder_.add_new_shape(new_shape);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *new_shape = nullptr) {
  auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
  return tflite::CreateReshapeOptions(
      _fbb,
      new_shape__);
}

struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SpaceToBatchNDOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SpaceToBatchNDOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SpaceToBatchNDOptionsBuilder {
  typedef SpaceToBatchNDOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SpaceToBatchNDOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SpaceToBatchNDOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SpaceToBatchNDOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BatchToSpaceNDOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BatchToSpaceNDOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct BatchToSpaceNDOptionsBuilder {
  typedef BatchToSpaceNDOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit BatchToSpaceNDOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BatchToSpaceNDOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  BatchToSpaceNDOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SkipGramOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SkipGramOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NGRAM_SIZE = 4,
    VT_MAX_SKIP_SIZE = 6,
    VT_INCLUDE_ALL_NGRAMS = 8
  };
  int32_t ngram_size() const {
    return GetField<int32_t>(VT_NGRAM_SIZE, 0);
  }
  bool mutate_ngram_size(int32_t _ngram_size = 0) {
    return SetField<int32_t>(VT_NGRAM_SIZE, _ngram_size, 0);
  }
  int32_t max_skip_size() const {
    return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0);
  }
  bool mutate_max_skip_size(int32_t _max_skip_size = 0) {
    return SetField<int32_t>(VT_MAX_SKIP_SIZE, _max_skip_size, 0);
  }
  bool include_all_ngrams() const {
    return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0;
  }
  bool mutate_include_all_ngrams(bool _include_all_ngrams = 0) {
    return SetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(_include_all_ngrams), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NGRAM_SIZE, 4) &&
           VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE, 4) &&
           VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS, 1) &&
           verifier.EndTable();
  }
};

struct SkipGramOptionsBuilder {
  typedef SkipGramOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ngram_size(int32_t ngram_size) {
    fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
  }
  void add_max_skip_size(int32_t max_skip_size) {
    fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
  }
  void add_include_all_ngrams(bool include_all_ngrams) {
    fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
  }
  explicit SkipGramOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SkipGramOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SkipGramOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t ngram_size = 0,
    int32_t max_skip_size = 0,
    bool include_all_ngrams = false) {
  SkipGramOptionsBuilder builder_(_fbb);
  builder_.add_max_skip_size(max_skip_size);
  builder_.add_ngram_size(ngram_size);
  builder_.add_include_all_ngrams(include_all_ngrams);
  return builder_.Finish();
}

struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SpaceToDepthOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SpaceToDepthOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BLOCK_SIZE = 4
  };
  int32_t block_size() const {
    return GetField<int32_t>(VT_BLOCK_SIZE, 0);
  }
  bool mutate_block_size(int32_t _block_size = 0) {
    return SetField<int32_t>(VT_BLOCK_SIZE, _block_size, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, 4) &&
           verifier.EndTable();
  }
};

struct SpaceToDepthOptionsBuilder {
  typedef SpaceToDepthOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_block_size(int32_t block_size) {
    fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
  }
  explicit SpaceToDepthOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SpaceToDepthOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SpaceToDepthOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t block_size = 0) {
  SpaceToDepthOptionsBuilder builder_(_fbb);
  builder_.add_block_size(block_size);
  return builder_.Finish();
}

struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DepthToSpaceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DepthToSpaceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BLOCK_SIZE = 4
  };
  int32_t block_size() const {
    return GetField<int32_t>(VT_BLOCK_SIZE, 0);
  }
  bool mutate_block_size(int32_t _block_size = 0) {
    return SetField<int32_t>(VT_BLOCK_SIZE, _block_size, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, 4) &&
           verifier.EndTable();
  }
};

struct DepthToSpaceOptionsBuilder {
  typedef DepthToSpaceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_block_size(int32_t block_size) {
    fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
  }
  explicit DepthToSpaceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DepthToSpaceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DepthToSpaceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t block_size = 0) {
  DepthToSpaceOptionsBuilder builder_(_fbb);
  builder_.add_block_size(block_size);
  return builder_.Finish();
}

struct SubOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SubOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SubOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4,
    VT_POT_SCALE_INT16 = 6
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool pot_scale_int16() const {
    return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
  }
  bool mutate_pot_scale_int16(bool _pot_scale_int16 = 1) {
    return SetField<uint8_t>(VT_POT_SCALE_INT16, static_cast<uint8_t>(_pot_scale_int16), 1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, 1) &&
           verifier.EndTable();
  }
};

struct SubOptionsBuilder {
  typedef SubOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_pot_scale_int16(bool pot_scale_int16) {
    fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
  }
  explicit SubOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SubOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SubOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SubOptions> CreateSubOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    bool pot_scale_int16 = true) {
  SubOptionsBuilder builder_(_fbb);
  builder_.add_pot_scale_int16(pot_scale_int16);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct DivOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DivOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DivOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUSED_ACTIVATION_FUNCTION = 4
  };
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           verifier.EndTable();
  }
};

struct DivOptionsBuilder {
  typedef DivOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  explicit DivOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DivOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DivOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DivOptions> CreateDivOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE) {
  DivOptionsBuilder builder_(_fbb);
  builder_.add_fused_activation_function(fused_activation_function);
  return builder_.Finish();
}

struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TopKV2OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TopKV2OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct TopKV2OptionsBuilder {
  typedef TopKV2Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit TopKV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TopKV2Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TopKV2Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  TopKV2OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmbeddingLookupSparseOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return EmbeddingLookupSparseOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMBINER = 4
  };
  tflite::CombinerType combiner() const {
    return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
  }
  bool mutate_combiner(tflite::CombinerType _combiner = static_cast<tflite::CombinerType>(0)) {
    return SetField<int8_t>(VT_COMBINER, static_cast<int8_t>(_combiner), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_COMBINER, 1) &&
           verifier.EndTable();
  }
};

struct EmbeddingLookupSparseOptionsBuilder {
  typedef EmbeddingLookupSparseOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_combiner(tflite::CombinerType combiner) {
    fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
  }
  explicit EmbeddingLookupSparseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::CombinerType combiner = tflite::CombinerType::SUM) {
  EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
  builder_.add_combiner(combiner);
  return builder_.Finish();
}

struct GatherOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GatherOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GatherOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_AXIS = 4,
    VT_BATCH_DIMS = 6
  };
  int32_t axis() const {
    return GetField<int32_t>(VT_AXIS, 0);
  }
  bool mutate_axis(int32_t _axis = 0) {
    return SetField<int32_t>(VT_AXIS, _axis, 0);
  }
  int32_t batch_dims() const {
    return GetField<int32_t>(VT_BATCH_DIMS, 0);
  }
  bool mutate_batch_dims(int32_t _batch_dims = 0) {
    return SetField<int32_t>(VT_BATCH_DIMS, _batch_dims, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           VerifyField<int32_t>(verifier, VT_BATCH_DIMS, 4) &&
           verifier.EndTable();
  }
};

struct GatherOptionsBuilder {
  typedef GatherOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0);
  }
  void add_batch_dims(int32_t batch_dims) {
    fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
  }
  explicit GatherOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GatherOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GatherOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<GatherOptions> CreateGatherOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t axis = 0,
    int32_t batch_dims = 0) {
  GatherOptionsBuilder builder_(_fbb);
  builder_.add_batch_dims(batch_dims);
  builder_.add_axis(axis);
  return builder_.Finish();
}

struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TransposeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TransposeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct TransposeOptionsBuilder {
  typedef TransposeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit TransposeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TransposeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TransposeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  TransposeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ExpOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ExpOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ExpOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ExpOptionsBuilder {
  typedef ExpOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ExpOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ExpOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ExpOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ExpOptions> CreateExpOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ExpOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct CosOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CosOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CosOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct CosOptionsBuilder {
  typedef CosOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit CosOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CosOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CosOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CosOptions> CreateCosOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  CosOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReducerOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReducerOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_KEEP_DIMS = 4
  };
  bool keep_dims() const {
    return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
  }
  bool mutate_keep_dims(bool _keep_dims = 0) {
    return SetField<uint8_t>(VT_KEEP_DIMS, static_cast<uint8_t>(_keep_dims), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_DIMS, 1) &&
           verifier.EndTable();
  }
};

struct ReducerOptionsBuilder {
  typedef ReducerOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_keep_dims(bool keep_dims) {
    fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
  }
  explicit ReducerOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReducerOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReducerOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool keep_dims = false) {
  ReducerOptionsBuilder builder_(_fbb);
  builder_.add_keep_dims(keep_dims);
  return builder_.Finish();
}

struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SqueezeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SqueezeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SQUEEZE_DIMS = 4
  };
  const ::flatbuffers::Vector<int32_t> *squeeze_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_squeeze_dims() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
           verifier.VerifyVector(squeeze_dims()) &&
           verifier.EndTable();
  }
};

struct SqueezeOptionsBuilder {
  typedef SqueezeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_squeeze_dims(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> squeeze_dims) {
    fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
  }
  explicit SqueezeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SqueezeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SqueezeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
  SqueezeOptionsBuilder builder_(_fbb);
  builder_.add_squeeze_dims(squeeze_dims);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *squeeze_dims = nullptr) {
  auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
  return tflite::CreateSqueezeOptions(
      _fbb,
      squeeze_dims__);
}

struct SplitOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SplitOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SplitOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM_SPLITS = 4
  };
  int32_t num_splits() const {
    return GetField<int32_t>(VT_NUM_SPLITS, 0);
  }
  bool mutate_num_splits(int32_t _num_splits = 0) {
    return SetField<int32_t>(VT_NUM_SPLITS, _num_splits, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NUM_SPLITS, 4) &&
           verifier.EndTable();
  }
};

struct SplitOptionsBuilder {
  typedef SplitOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_num_splits(int32_t num_splits) {
    fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
  }
  explicit SplitOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SplitOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SplitOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SplitOptions> CreateSplitOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_splits = 0) {
  SplitOptionsBuilder builder_(_fbb);
  builder_.add_num_splits(num_splits);
  return builder_.Finish();
}

struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SplitVOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SplitVOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM_SPLITS = 4
  };
  int32_t num_splits() const {
    return GetField<int32_t>(VT_NUM_SPLITS, 0);
  }
  bool mutate_num_splits(int32_t _num_splits = 0) {
    return SetField<int32_t>(VT_NUM_SPLITS, _num_splits, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NUM_SPLITS, 4) &&
           verifier.EndTable();
  }
};

struct SplitVOptionsBuilder {
  typedef SplitVOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_num_splits(int32_t num_splits) {
    fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
  }
  explicit SplitVOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SplitVOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SplitVOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num_splits = 0) {
  SplitVOptionsBuilder builder_(_fbb);
  builder_.add_num_splits(num_splits);
  return builder_.Finish();
}

struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StridedSliceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StridedSliceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BEGIN_MASK = 4,
    VT_END_MASK = 6,
    VT_ELLIPSIS_MASK = 8,
    VT_NEW_AXIS_MASK = 10,
    VT_SHRINK_AXIS_MASK = 12,
    VT_OFFSET = 14
  };
  int32_t begin_mask() const {
    return GetField<int32_t>(VT_BEGIN_MASK, 0);
  }
  bool mutate_begin_mask(int32_t _begin_mask = 0) {
    return SetField<int32_t>(VT_BEGIN_MASK, _begin_mask, 0);
  }
  int32_t end_mask() const {
    return GetField<int32_t>(VT_END_MASK, 0);
  }
  bool mutate_end_mask(int32_t _end_mask = 0) {
    return SetField<int32_t>(VT_END_MASK, _end_mask, 0);
  }
  int32_t ellipsis_mask() const {
    return GetField<int32_t>(VT_ELLIPSIS_MASK, 0);
  }
  bool mutate_ellipsis_mask(int32_t _ellipsis_mask = 0) {
    return SetField<int32_t>(VT_ELLIPSIS_MASK, _ellipsis_mask, 0);
  }
  int32_t new_axis_mask() const {
    return GetField<int32_t>(VT_NEW_AXIS_MASK, 0);
  }
  bool mutate_new_axis_mask(int32_t _new_axis_mask = 0) {
    return SetField<int32_t>(VT_NEW_AXIS_MASK, _new_axis_mask, 0);
  }
  int32_t shrink_axis_mask() const {
    return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0);
  }
  bool mutate_shrink_axis_mask(int32_t _shrink_axis_mask = 0) {
    return SetField<int32_t>(VT_SHRINK_AXIS_MASK, _shrink_axis_mask, 0);
  }
  bool offset() const {
    return GetField<uint8_t>(VT_OFFSET, 0) != 0;
  }
  bool mutate_offset(bool _offset = 0) {
    return SetField<uint8_t>(VT_OFFSET, static_cast<uint8_t>(_offset), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_BEGIN_MASK, 4) &&
           VerifyField<int32_t>(verifier, VT_END_MASK, 4) &&
           VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK, 4) &&
           VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK, 4) &&
           VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK, 4) &&
           VerifyField<uint8_t>(verifier, VT_OFFSET, 1) &&
           verifier.EndTable();
  }
};

struct StridedSliceOptionsBuilder {
  typedef StridedSliceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_begin_mask(int32_t begin_mask) {
    fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
  }
  void add_end_mask(int32_t end_mask) {
    fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
  }
  void add_ellipsis_mask(int32_t ellipsis_mask) {
    fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
  }
  void add_new_axis_mask(int32_t new_axis_mask) {
    fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
  }
  void add_shrink_axis_mask(int32_t shrink_axis_mask) {
    fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
  }
  void add_offset(bool offset) {
    fbb_.AddElement<uint8_t>(StridedSliceOptions::VT_OFFSET, static_cast<uint8_t>(offset), 0);
  }
  explicit StridedSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StridedSliceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StridedSliceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t begin_mask = 0,
    int32_t end_mask = 0,
    int32_t ellipsis_mask = 0,
    int32_t new_axis_mask = 0,
    int32_t shrink_axis_mask = 0,
    bool offset = false) {
  StridedSliceOptionsBuilder builder_(_fbb);
  builder_.add_shrink_axis_mask(shrink_axis_mask);
  builder_.add_new_axis_mask(new_axis_mask);
  builder_.add_ellipsis_mask(ellipsis_mask);
  builder_.add_end_mask(end_mask);
  builder_.add_begin_mask(begin_mask);
  builder_.add_offset(offset);
  return builder_.Finish();
}

struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogSoftmaxOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LogSoftmaxOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LogSoftmaxOptionsBuilder {
  typedef LogSoftmaxOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LogSoftmaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogSoftmaxOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogSoftmaxOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LogSoftmaxOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct CastOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CastOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CastOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN_DATA_TYPE = 4,
    VT_OUT_DATA_TYPE = 6
  };
  tflite::TensorType in_data_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
  }
  bool mutate_in_data_type(tflite::TensorType _in_data_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_IN_DATA_TYPE, static_cast<int8_t>(_in_data_type), 0);
  }
  tflite::TensorType out_data_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
  }
  bool mutate_out_data_type(tflite::TensorType _out_data_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_OUT_DATA_TYPE, static_cast<int8_t>(_out_data_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE, 1) &&
           VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct CastOptionsBuilder {
  typedef CastOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in_data_type(tflite::TensorType in_data_type) {
    fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
  }
  void add_out_data_type(tflite::TensorType out_data_type) {
    fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
  }
  explicit CastOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CastOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CastOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CastOptions> CreateCastOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::TensorType in_data_type = tflite::TensorType::FLOAT32,
    tflite::TensorType out_data_type = tflite::TensorType::FLOAT32) {
  CastOptionsBuilder builder_(_fbb);
  builder_.add_out_data_type(out_data_type);
  builder_.add_in_data_type(in_data_type);
  return builder_.Finish();
}

struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DequantizeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DequantizeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct DequantizeOptionsBuilder {
  typedef DequantizeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit DequantizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DequantizeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DequantizeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  DequantizeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MaximumMinimumOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MaximumMinimumOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct MaximumMinimumOptionsBuilder {
  typedef MaximumMinimumOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit MaximumMinimumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MaximumMinimumOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MaximumMinimumOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  MaximumMinimumOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct TileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TileOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TileOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct TileOptionsBuilder {
  typedef TileOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit TileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TileOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TileOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TileOptions> CreateTileOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  TileOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ArgMaxOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ArgMaxOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OUTPUT_TYPE = 4
  };
  tflite::TensorType output_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
  }
  bool mutate_output_type(tflite::TensorType _output_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_OUTPUT_TYPE, static_cast<int8_t>(_output_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct ArgMaxOptionsBuilder {
  typedef ArgMaxOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_output_type(tflite::TensorType output_type) {
    fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
  }
  explicit ArgMaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ArgMaxOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ArgMaxOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::TensorType output_type = tflite::TensorType::FLOAT32) {
  ArgMaxOptionsBuilder builder_(_fbb);
  builder_.add_output_type(output_type);
  return builder_.Finish();
}

struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ArgMinOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ArgMinOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OUTPUT_TYPE = 4
  };
  tflite::TensorType output_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
  }
  bool mutate_output_type(tflite::TensorType _output_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_OUTPUT_TYPE, static_cast<int8_t>(_output_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct ArgMinOptionsBuilder {
  typedef ArgMinOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_output_type(tflite::TensorType output_type) {
    fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
  }
  explicit ArgMinOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ArgMinOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ArgMinOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::TensorType output_type = tflite::TensorType::FLOAT32) {
  ArgMinOptionsBuilder builder_(_fbb);
  builder_.add_output_type(output_type);
  return builder_.Finish();
}

struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GreaterOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GreaterOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct GreaterOptionsBuilder {
  typedef GreaterOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit GreaterOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GreaterOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GreaterOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  GreaterOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GreaterEqualOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GreaterEqualOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct GreaterEqualOptionsBuilder {
  typedef GreaterEqualOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit GreaterEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GreaterEqualOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GreaterEqualOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  GreaterEqualOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct LessOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LessOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LessOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LessOptionsBuilder {
  typedef LessOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LessOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LessOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LessOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LessOptions> CreateLessOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LessOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LessEqualOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LessEqualOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LessEqualOptionsBuilder {
  typedef LessEqualOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LessEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LessEqualOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LessEqualOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LessEqualOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct NegOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NegOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return NegOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct NegOptionsBuilder {
  typedef NegOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit NegOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NegOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NegOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NegOptions> CreateNegOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  NegOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SelectOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SelectOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SelectOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SelectOptionsBuilder {
  typedef SelectOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SelectOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SelectOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SelectOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SelectOptions> CreateSelectOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SelectOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SliceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SliceOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SliceOptionsBuilder {
  typedef SliceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SliceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SliceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SliceOptions> CreateSliceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SliceOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TransposeConvOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TransposeConvOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PADDING = 4,
    VT_STRIDE_W = 6,
    VT_STRIDE_H = 8,
    VT_FUSED_ACTIVATION_FUNCTION = 10,
    VT_QUANTIZED_BIAS_TYPE = 12
  };
  tflite::Padding padding() const {
    return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
  }
  bool mutate_padding(tflite::Padding _padding = static_cast<tflite::Padding>(0)) {
    return SetField<int8_t>(VT_PADDING, static_cast<int8_t>(_padding), 0);
  }
  int32_t stride_w() const {
    return GetField<int32_t>(VT_STRIDE_W, 0);
  }
  bool mutate_stride_w(int32_t _stride_w = 0) {
    return SetField<int32_t>(VT_STRIDE_W, _stride_w, 0);
  }
  int32_t stride_h() const {
    return GetField<int32_t>(VT_STRIDE_H, 0);
  }
  bool mutate_stride_h(int32_t _stride_h = 0) {
    return SetField<int32_t>(VT_STRIDE_H, _stride_h, 0);
  }
  tflite::ActivationFunctionType fused_activation_function() const {
    return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
  }
  bool mutate_fused_activation_function(tflite::ActivationFunctionType _fused_activation_function = static_cast<tflite::ActivationFunctionType>(0)) {
    return SetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(_fused_activation_function), 0);
  }
  tflite::TensorType quantized_bias_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, 0));
  }
  bool mutate_quantized_bias_type(tflite::TensorType _quantized_bias_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(_quantized_bias_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
           VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
           VerifyField<int8_t>(verifier, VT_QUANTIZED_BIAS_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct TransposeConvOptionsBuilder {
  typedef TransposeConvOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_padding(tflite::Padding padding) {
    fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
  }
  void add_stride_w(int32_t stride_w) {
    fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
  }
  void add_stride_h(int32_t stride_h) {
    fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
  }
  void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
    fbb_.AddElement<int8_t>(TransposeConvOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
  }
  void add_quantized_bias_type(tflite::TensorType quantized_bias_type) {
    fbb_.AddElement<int8_t>(TransposeConvOptions::VT_QUANTIZED_BIAS_TYPE, static_cast<int8_t>(quantized_bias_type), 0);
  }
  explicit TransposeConvOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TransposeConvOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TransposeConvOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::Padding padding = tflite::Padding::SAME,
    int32_t stride_w = 0,
    int32_t stride_h = 0,
    tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType::NONE,
    tflite::TensorType quantized_bias_type = tflite::TensorType::FLOAT32) {
  TransposeConvOptionsBuilder builder_(_fbb);
  builder_.add_stride_h(stride_h);
  builder_.add_stride_w(stride_w);
  builder_.add_quantized_bias_type(quantized_bias_type);
  builder_.add_fused_activation_function(fused_activation_function);
  builder_.add_padding(padding);
  return builder_.Finish();
}

struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ExpandDimsOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ExpandDimsOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ExpandDimsOptionsBuilder {
  typedef ExpandDimsOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ExpandDimsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ExpandDimsOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ExpandDimsOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ExpandDimsOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SparseToDenseOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SparseToDenseOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALIDATE_INDICES = 4
  };
  bool validate_indices() const {
    return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0;
  }
  bool mutate_validate_indices(bool _validate_indices = 0) {
    return SetField<uint8_t>(VT_VALIDATE_INDICES, static_cast<uint8_t>(_validate_indices), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES, 1) &&
           verifier.EndTable();
  }
};

struct SparseToDenseOptionsBuilder {
  typedef SparseToDenseOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_validate_indices(bool validate_indices) {
    fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0);
  }
  explicit SparseToDenseOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SparseToDenseOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SparseToDenseOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool validate_indices = false) {
  SparseToDenseOptionsBuilder builder_(_fbb);
  builder_.add_validate_indices(validate_indices);
  return builder_.Finish();
}

struct EqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EqualOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return EqualOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct EqualOptionsBuilder {
  typedef EqualOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit EqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EqualOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EqualOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<EqualOptions> CreateEqualOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  EqualOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NotEqualOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return NotEqualOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct NotEqualOptionsBuilder {
  typedef NotEqualOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit NotEqualOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NotEqualOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NotEqualOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  NotEqualOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShapeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ShapeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OUT_TYPE = 4
  };
  tflite::TensorType out_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
  }
  bool mutate_out_type(tflite::TensorType _out_type = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_OUT_TYPE, static_cast<int8_t>(_out_type), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_OUT_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct ShapeOptionsBuilder {
  typedef ShapeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_out_type(tflite::TensorType out_type) {
    fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
  }
  explicit ShapeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShapeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShapeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::TensorType out_type = tflite::TensorType::FLOAT32) {
  ShapeOptionsBuilder builder_(_fbb);
  builder_.add_out_type(out_type);
  return builder_.Finish();
}

struct RankOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RankOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RankOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct RankOptionsBuilder {
  typedef RankOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit RankOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RankOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RankOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RankOptions> CreateRankOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  RankOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct PowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PowOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PowOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct PowOptionsBuilder {
  typedef PowOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit PowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PowOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PowOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PowOptions> CreatePowOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  PowOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FakeQuantOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FakeQuantOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MIN = 4,
    VT_MAX = 6,
    VT_NUM_BITS = 8,
    VT_NARROW_RANGE = 10
  };
  float min() const {
    return GetField<float>(VT_MIN, 0.0f);
  }
  bool mutate_min(float _min = 0.0f) {
    return SetField<float>(VT_MIN, _min, 0.0f);
  }
  float max() const {
    return GetField<float>(VT_MAX, 0.0f);
  }
  bool mutate_max(float _max = 0.0f) {
    return SetField<float>(VT_MAX, _max, 0.0f);
  }
  int32_t num_bits() const {
    return GetField<int32_t>(VT_NUM_BITS, 0);
  }
  bool mutate_num_bits(int32_t _num_bits = 0) {
    return SetField<int32_t>(VT_NUM_BITS, _num_bits, 0);
  }
  bool narrow_range() const {
    return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0;
  }
  bool mutate_narrow_range(bool _narrow_range = 0) {
    return SetField<uint8_t>(VT_NARROW_RANGE, static_cast<uint8_t>(_narrow_range), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_MIN, 4) &&
           VerifyField<float>(verifier, VT_MAX, 4) &&
           VerifyField<int32_t>(verifier, VT_NUM_BITS, 4) &&
           VerifyField<uint8_t>(verifier, VT_NARROW_RANGE, 1) &&
           verifier.EndTable();
  }
};

struct FakeQuantOptionsBuilder {
  typedef FakeQuantOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_min(float min) {
    fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f);
  }
  void add_max(float max) {
    fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f);
  }
  void add_num_bits(int32_t num_bits) {
    fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
  }
  void add_narrow_range(bool narrow_range) {
    fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0);
  }
  explicit FakeQuantOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FakeQuantOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FakeQuantOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float min = 0.0f,
    float max = 0.0f,
    int32_t num_bits = 0,
    bool narrow_range = false) {
  FakeQuantOptionsBuilder builder_(_fbb);
  builder_.add_num_bits(num_bits);
  builder_.add_max(max);
  builder_.add_min(min);
  builder_.add_narrow_range(narrow_range);
  return builder_.Finish();
}

struct PackOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PackOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PackOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUES_COUNT = 4,
    VT_AXIS = 6
  };
  int32_t values_count() const {
    return GetField<int32_t>(VT_VALUES_COUNT, 0);
  }
  bool mutate_values_count(int32_t _values_count = 0) {
    return SetField<int32_t>(VT_VALUES_COUNT, _values_count, 0);
  }
  int32_t axis() const {
    return GetField<int32_t>(VT_AXIS, 0);
  }
  bool mutate_axis(int32_t _axis = 0) {
    return SetField<int32_t>(VT_AXIS, _axis, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_VALUES_COUNT, 4) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           verifier.EndTable();
  }
};

struct PackOptionsBuilder {
  typedef PackOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_values_count(int32_t values_count) {
    fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
  }
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0);
  }
  explicit PackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PackOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PackOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PackOptions> CreatePackOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t values_count = 0,
    int32_t axis = 0) {
  PackOptionsBuilder builder_(_fbb);
  builder_.add_axis(axis);
  builder_.add_values_count(values_count);
  return builder_.Finish();
}

struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogicalOrOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LogicalOrOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LogicalOrOptionsBuilder {
  typedef LogicalOrOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LogicalOrOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogicalOrOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogicalOrOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LogicalOrOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OneHotOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return OneHotOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_AXIS = 4
  };
  int32_t axis() const {
    return GetField<int32_t>(VT_AXIS, 0);
  }
  bool mutate_axis(int32_t _axis = 0) {
    return SetField<int32_t>(VT_AXIS, _axis, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           verifier.EndTable();
  }
};

struct OneHotOptionsBuilder {
  typedef OneHotOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0);
  }
  explicit OneHotOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<OneHotOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<OneHotOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t axis = 0) {
  OneHotOptionsBuilder builder_(_fbb);
  builder_.add_axis(axis);
  return builder_.Finish();
}

struct AbsOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AbsOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AbsOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct AbsOptionsBuilder {
  typedef AbsOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit AbsOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AbsOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AbsOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<AbsOptions> CreateAbsOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AbsOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HardSwishOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return HardSwishOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct HardSwishOptionsBuilder {
  typedef HardSwishOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit HardSwishOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HardSwishOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HardSwishOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  HardSwishOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogicalAndOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LogicalAndOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LogicalAndOptionsBuilder {
  typedef LogicalAndOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LogicalAndOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogicalAndOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogicalAndOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LogicalAndOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogicalNotOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LogicalNotOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct LogicalNotOptionsBuilder {
  typedef LogicalNotOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit LogicalNotOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogicalNotOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogicalNotOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  LogicalNotOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnpackOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnpackOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM = 4,
    VT_AXIS = 6
  };
  int32_t num() const {
    return GetField<int32_t>(VT_NUM, 0);
  }
  bool mutate_num(int32_t _num = 0) {
    return SetField<int32_t>(VT_NUM, _num, 0);
  }
  int32_t axis() const {
    return GetField<int32_t>(VT_AXIS, 0);
  }
  bool mutate_axis(int32_t _axis = 0) {
    return SetField<int32_t>(VT_AXIS, _axis, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_NUM, 4) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           verifier.EndTable();
  }
};

struct UnpackOptionsBuilder {
  typedef UnpackOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_num(int32_t num) {
    fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0);
  }
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0);
  }
  explicit UnpackOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnpackOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnpackOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t num = 0,
    int32_t axis = 0) {
  UnpackOptionsBuilder builder_(_fbb);
  builder_.add_axis(axis);
  builder_.add_num(num);
  return builder_.Finish();
}

struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FloorDivOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FloorDivOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct FloorDivOptionsBuilder {
  typedef FloorDivOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit FloorDivOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FloorDivOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FloorDivOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  FloorDivOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SquareOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SquareOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SquareOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SquareOptionsBuilder {
  typedef SquareOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SquareOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SquareOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SquareOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SquareOptions> CreateSquareOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SquareOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ZerosLikeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ZerosLikeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ZerosLikeOptionsBuilder {
  typedef ZerosLikeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ZerosLikeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ZerosLikeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ZerosLikeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ZerosLikeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct FillOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FillOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FillOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct FillOptionsBuilder {
  typedef FillOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit FillOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FillOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FillOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<FillOptions> CreateFillOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  FillOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FloorModOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return FloorModOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct FloorModOptionsBuilder {
  typedef FloorModOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit FloorModOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FloorModOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FloorModOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  FloorModOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct RangeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RangeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RangeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct RangeOptionsBuilder {
  typedef RangeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit RangeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RangeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RangeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RangeOptions> CreateRangeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  RangeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LeakyReluOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LeakyReluOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ALPHA = 4
  };
  float alpha() const {
    return GetField<float>(VT_ALPHA, 0.0f);
  }
  bool mutate_alpha(float _alpha = 0.0f) {
    return SetField<float>(VT_ALPHA, _alpha, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_ALPHA, 4) &&
           verifier.EndTable();
  }
};

struct LeakyReluOptionsBuilder {
  typedef LeakyReluOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_alpha(float alpha) {
    fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f);
  }
  explicit LeakyReluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LeakyReluOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LeakyReluOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float alpha = 0.0f) {
  LeakyReluOptionsBuilder builder_(_fbb);
  builder_.add_alpha(alpha);
  return builder_.Finish();
}

struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SquaredDifferenceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SquaredDifferenceOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SquaredDifferenceOptionsBuilder {
  typedef SquaredDifferenceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SquaredDifferenceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SquaredDifferenceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SquaredDifferenceOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MirrorPadOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MirrorPadOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MODE = 4
  };
  tflite::MirrorPadMode mode() const {
    return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
  }
  bool mutate_mode(tflite::MirrorPadMode _mode = static_cast<tflite::MirrorPadMode>(0)) {
    return SetField<int8_t>(VT_MODE, static_cast<int8_t>(_mode), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_MODE, 1) &&
           verifier.EndTable();
  }
};

struct MirrorPadOptionsBuilder {
  typedef MirrorPadOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_mode(tflite::MirrorPadMode mode) {
    fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
  }
  explicit MirrorPadOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MirrorPadOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MirrorPadOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::MirrorPadMode mode = tflite::MirrorPadMode::REFLECT) {
  MirrorPadOptionsBuilder builder_(_fbb);
  builder_.add_mode(mode);
  return builder_.Finish();
}

struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UniqueOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UniqueOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IDX_OUT_TYPE = 4
  };
  tflite::TensorType idx_out_type() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
  }
  bool mutate_idx_out_type(tflite::TensorType _idx_out_type = static_cast<tflite::TensorType>(2)) {
    return SetField<int8_t>(VT_IDX_OUT_TYPE, static_cast<int8_t>(_idx_out_type), 2);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE, 1) &&
           verifier.EndTable();
  }
};

struct UniqueOptionsBuilder {
  typedef UniqueOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_idx_out_type(tflite::TensorType idx_out_type) {
    fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
  }
  explicit UniqueOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UniqueOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UniqueOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::TensorType idx_out_type = tflite::TensorType::INT32) {
  UniqueOptionsBuilder builder_(_fbb);
  builder_.add_idx_out_type(idx_out_type);
  return builder_.Finish();
}

struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReverseV2OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReverseV2OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ReverseV2OptionsBuilder {
  typedef ReverseV2Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ReverseV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReverseV2Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReverseV2Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ReverseV2OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct AddNOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AddNOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AddNOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct AddNOptionsBuilder {
  typedef AddNOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit AddNOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AddNOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AddNOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<AddNOptions> CreateAddNOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AddNOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GatherNdOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GatherNdOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct GatherNdOptionsBuilder {
  typedef GatherNdOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit GatherNdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GatherNdOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GatherNdOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  GatherNdOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct WhereOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef WhereOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return WhereOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct WhereOptionsBuilder {
  typedef WhereOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit WhereOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<WhereOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<WhereOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<WhereOptions> CreateWhereOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  WhereOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReverseSequenceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReverseSequenceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ_DIM = 4,
    VT_BATCH_DIM = 6
  };
  int32_t seq_dim() const {
    return GetField<int32_t>(VT_SEQ_DIM, 0);
  }
  bool mutate_seq_dim(int32_t _seq_dim = 0) {
    return SetField<int32_t>(VT_SEQ_DIM, _seq_dim, 0);
  }
  int32_t batch_dim() const {
    return GetField<int32_t>(VT_BATCH_DIM, 0);
  }
  bool mutate_batch_dim(int32_t _batch_dim = 0) {
    return SetField<int32_t>(VT_BATCH_DIM, _batch_dim, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_SEQ_DIM, 4) &&
           VerifyField<int32_t>(verifier, VT_BATCH_DIM, 4) &&
           verifier.EndTable();
  }
};

struct ReverseSequenceOptionsBuilder {
  typedef ReverseSequenceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq_dim(int32_t seq_dim) {
    fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
  }
  void add_batch_dim(int32_t batch_dim) {
    fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
  }
  explicit ReverseSequenceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReverseSequenceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReverseSequenceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t seq_dim = 0,
    int32_t batch_dim = 0) {
  ReverseSequenceOptionsBuilder builder_(_fbb);
  builder_.add_batch_dim(batch_dim);
  builder_.add_seq_dim(seq_dim);
  return builder_.Finish();
}

struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatrixDiagOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MatrixDiagOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct MatrixDiagOptionsBuilder {
  typedef MatrixDiagOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit MatrixDiagOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatrixDiagOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatrixDiagOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  MatrixDiagOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef QuantizeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return QuantizeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct QuantizeOptionsBuilder {
  typedef QuantizeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit QuantizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<QuantizeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<QuantizeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  QuantizeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatrixSetDiagOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MatrixSetDiagOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct MatrixSetDiagOptionsBuilder {
  typedef MatrixSetDiagOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit MatrixSetDiagOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatrixSetDiagOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  MatrixSetDiagOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct IfOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IfOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return IfOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_THEN_SUBGRAPH_INDEX = 4,
    VT_ELSE_SUBGRAPH_INDEX = 6
  };
  int32_t then_subgraph_index() const {
    return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0);
  }
  bool mutate_then_subgraph_index(int32_t _then_subgraph_index = 0) {
    return SetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, _then_subgraph_index, 0);
  }
  int32_t else_subgraph_index() const {
    return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0);
  }
  bool mutate_else_subgraph_index(int32_t _else_subgraph_index = 0) {
    return SetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, _else_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX, 4) &&
           VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct IfOptionsBuilder {
  typedef IfOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_then_subgraph_index(int32_t then_subgraph_index) {
    fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
  }
  void add_else_subgraph_index(int32_t else_subgraph_index) {
    fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
  }
  explicit IfOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<IfOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<IfOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<IfOptions> CreateIfOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t then_subgraph_index = 0,
    int32_t else_subgraph_index = 0) {
  IfOptionsBuilder builder_(_fbb);
  builder_.add_else_subgraph_index(else_subgraph_index);
  builder_.add_then_subgraph_index(then_subgraph_index);
  return builder_.Finish();
}

struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CallOnceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CallOnceOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INIT_SUBGRAPH_INDEX = 4
  };
  int32_t init_subgraph_index() const {
    return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0);
  }
  bool mutate_init_subgraph_index(int32_t _init_subgraph_index = 0) {
    return SetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, _init_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct CallOnceOptionsBuilder {
  typedef CallOnceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_init_subgraph_index(int32_t init_subgraph_index) {
    fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0);
  }
  explicit CallOnceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CallOnceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CallOnceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t init_subgraph_index = 0) {
  CallOnceOptionsBuilder builder_(_fbb);
  builder_.add_init_subgraph_index(init_subgraph_index);
  return builder_.Finish();
}

struct WhileOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef WhileOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return WhileOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COND_SUBGRAPH_INDEX = 4,
    VT_BODY_SUBGRAPH_INDEX = 6
  };
  int32_t cond_subgraph_index() const {
    return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0);
  }
  bool mutate_cond_subgraph_index(int32_t _cond_subgraph_index = 0) {
    return SetField<int32_t>(VT_COND_SUBGRAPH_INDEX, _cond_subgraph_index, 0);
  }
  int32_t body_subgraph_index() const {
    return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
  }
  bool mutate_body_subgraph_index(int32_t _body_subgraph_index = 0) {
    return SetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, _body_subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, 4) &&
           VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct WhileOptionsBuilder {
  typedef WhileOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_cond_subgraph_index(int32_t cond_subgraph_index) {
    fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
  }
  void add_body_subgraph_index(int32_t body_subgraph_index) {
    fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
  }
  explicit WhileOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<WhileOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<WhileOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<WhileOptions> CreateWhileOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t cond_subgraph_index = 0,
    int32_t body_subgraph_index = 0) {
  WhileOptionsBuilder builder_(_fbb);
  builder_.add_body_subgraph_index(body_subgraph_index);
  builder_.add_cond_subgraph_index(cond_subgraph_index);
  return builder_.Finish();
}

struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NonMaxSuppressionV4OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return NonMaxSuppressionV4OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct NonMaxSuppressionV4OptionsBuilder {
  typedef NonMaxSuppressionV4Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit NonMaxSuppressionV4OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NonMaxSuppressionV5OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return NonMaxSuppressionV5OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct NonMaxSuppressionV5OptionsBuilder {
  typedef NonMaxSuppressionV5Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit NonMaxSuppressionV5OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ScatterNdOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ScatterNdOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ScatterNdOptionsBuilder {
  typedef ScatterNdOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ScatterNdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ScatterNdOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ScatterNdOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ScatterNdOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SelectV2OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SelectV2OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SelectV2OptionsBuilder {
  typedef SelectV2Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SelectV2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SelectV2Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SelectV2Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SelectV2OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DensifyOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DensifyOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct DensifyOptionsBuilder {
  typedef DensifyOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit DensifyOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DensifyOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DensifyOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  DensifyOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SegmentSumOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SegmentSumOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SegmentSumOptionsBuilder {
  typedef SegmentSumOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SegmentSumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SegmentSumOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SegmentSumOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SegmentSumOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BatchMatMulOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BatchMatMulOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ADJ_X = 4,
    VT_ADJ_Y = 6,
    VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
  };
  bool adj_x() const {
    return GetField<uint8_t>(VT_ADJ_X, 0) != 0;
  }
  bool mutate_adj_x(bool _adj_x = 0) {
    return SetField<uint8_t>(VT_ADJ_X, static_cast<uint8_t>(_adj_x), 0);
  }
  bool adj_y() const {
    return GetField<uint8_t>(VT_ADJ_Y, 0) != 0;
  }
  bool mutate_adj_y(bool _adj_y = 0) {
    return SetField<uint8_t>(VT_ADJ_Y, static_cast<uint8_t>(_adj_y), 0);
  }
  bool asymmetric_quantize_inputs() const {
    return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
  }
  bool mutate_asymmetric_quantize_inputs(bool _asymmetric_quantize_inputs = 0) {
    return SetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(_asymmetric_quantize_inputs), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ADJ_X, 1) &&
           VerifyField<uint8_t>(verifier, VT_ADJ_Y, 1) &&
           VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
           verifier.EndTable();
  }
};

struct BatchMatMulOptionsBuilder {
  typedef BatchMatMulOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_adj_x(bool adj_x) {
    fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), 0);
  }
  void add_adj_y(bool adj_y) {
    fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), 0);
  }
  void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
    fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
  }
  explicit BatchMatMulOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BatchMatMulOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BatchMatMulOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool adj_x = false,
    bool adj_y = false,
    bool asymmetric_quantize_inputs = false) {
  BatchMatMulOptionsBuilder builder_(_fbb);
  builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
  builder_.add_adj_y(adj_y);
  builder_.add_adj_x(adj_x);
  return builder_.Finish();
}

struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CumsumOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return CumsumOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_EXCLUSIVE = 4,
    VT_REVERSE = 6
  };
  bool exclusive() const {
    return GetField<uint8_t>(VT_EXCLUSIVE, 0) != 0;
  }
  bool mutate_exclusive(bool _exclusive = 0) {
    return SetField<uint8_t>(VT_EXCLUSIVE, static_cast<uint8_t>(_exclusive), 0);
  }
  bool reverse() const {
    return GetField<uint8_t>(VT_REVERSE, 0) != 0;
  }
  bool mutate_reverse(bool _reverse = 0) {
    return SetField<uint8_t>(VT_REVERSE, static_cast<uint8_t>(_reverse), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_EXCLUSIVE, 1) &&
           VerifyField<uint8_t>(verifier, VT_REVERSE, 1) &&
           verifier.EndTable();
  }
};

struct CumsumOptionsBuilder {
  typedef CumsumOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_exclusive(bool exclusive) {
    fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
  }
  void add_reverse(bool reverse) {
    fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
  }
  explicit CumsumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CumsumOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CumsumOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool exclusive = false,
    bool reverse = false) {
  CumsumOptionsBuilder builder_(_fbb);
  builder_.add_reverse(reverse);
  builder_.add_exclusive(exclusive);
  return builder_.Finish();
}

struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BroadcastToOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BroadcastToOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct BroadcastToOptionsBuilder {
  typedef BroadcastToOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit BroadcastToOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BroadcastToOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BroadcastToOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  BroadcastToOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Rfft2dOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Rfft2dOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct Rfft2dOptionsBuilder {
  typedef Rfft2dOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit Rfft2dOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Rfft2dOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Rfft2dOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  Rfft2dOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HashtableOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return HashtableOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TABLE_ID = 4,
    VT_KEY_DTYPE = 6,
    VT_VALUE_DTYPE = 8
  };
  int32_t table_id() const {
    return GetField<int32_t>(VT_TABLE_ID, 0);
  }
  bool mutate_table_id(int32_t _table_id = 0) {
    return SetField<int32_t>(VT_TABLE_ID, _table_id, 0);
  }
  tflite::TensorType key_dtype() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, 0));
  }
  bool mutate_key_dtype(tflite::TensorType _key_dtype = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_KEY_DTYPE, static_cast<int8_t>(_key_dtype), 0);
  }
  tflite::TensorType value_dtype() const {
    return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
  }
  bool mutate_value_dtype(tflite::TensorType _value_dtype = static_cast<tflite::TensorType>(0)) {
    return SetField<int8_t>(VT_VALUE_DTYPE, static_cast<int8_t>(_value_dtype), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_TABLE_ID, 4) &&
           VerifyField<int8_t>(verifier, VT_KEY_DTYPE, 1) &&
           VerifyField<int8_t>(verifier, VT_VALUE_DTYPE, 1) &&
           verifier.EndTable();
  }
};

struct HashtableOptionsBuilder {
  typedef HashtableOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_table_id(int32_t table_id) {
    fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
  }
  void add_key_dtype(tflite::TensorType key_dtype) {
    fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), 0);
  }
  void add_value_dtype(tflite::TensorType value_dtype) {
    fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
  }
  explicit HashtableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HashtableOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HashtableOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t table_id = 0,
    tflite::TensorType key_dtype = tflite::TensorType::FLOAT32,
    tflite::TensorType value_dtype = tflite::TensorType::FLOAT32) {
  HashtableOptionsBuilder builder_(_fbb);
  builder_.add_table_id(table_id);
  builder_.add_value_dtype(value_dtype);
  builder_.add_key_dtype(key_dtype);
  return builder_.Finish();
}

struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HashtableFindOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return HashtableFindOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct HashtableFindOptionsBuilder {
  typedef HashtableFindOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit HashtableFindOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HashtableFindOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HashtableFindOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  HashtableFindOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HashtableImportOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return HashtableImportOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct HashtableImportOptionsBuilder {
  typedef HashtableImportOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit HashtableImportOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HashtableImportOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HashtableImportOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  HashtableImportOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HashtableSizeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return HashtableSizeOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct HashtableSizeOptionsBuilder {
  typedef HashtableSizeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit HashtableSizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<HashtableSizeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<HashtableSizeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  HashtableSizeOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VarHandleOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return VarHandleOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CONTAINER = 4,
    VT_SHARED_NAME = 6
  };
  const ::flatbuffers::String *container() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CONTAINER);
  }
  ::flatbuffers::String *mutable_container() {
    return GetPointer<::flatbuffers::String *>(VT_CONTAINER);
  }
  const ::flatbuffers::String *shared_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_SHARED_NAME);
  }
  ::flatbuffers::String *mutable_shared_name() {
    return GetPointer<::flatbuffers::String *>(VT_SHARED_NAME);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CONTAINER) &&
           verifier.VerifyString(container()) &&
           VerifyOffset(verifier, VT_SHARED_NAME) &&
           verifier.VerifyString(shared_name()) &&
           verifier.EndTable();
  }
};

struct VarHandleOptionsBuilder {
  typedef VarHandleOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_container(::flatbuffers::Offset<::flatbuffers::String> container) {
    fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container);
  }
  void add_shared_name(::flatbuffers::Offset<::flatbuffers::String> shared_name) {
    fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name);
  }
  explicit VarHandleOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VarHandleOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VarHandleOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> container = 0,
    ::flatbuffers::Offset<::flatbuffers::String> shared_name = 0) {
  VarHandleOptionsBuilder builder_(_fbb);
  builder_.add_shared_name(shared_name);
  builder_.add_container(container);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *container = nullptr,
    const char *shared_name = nullptr) {
  auto container__ = container ? _fbb.CreateString(container) : 0;
  auto shared_name__ = shared_name ? _fbb.CreateString(shared_name) : 0;
  return tflite::CreateVarHandleOptions(
      _fbb,
      container__,
      shared_name__);
}

struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReadVariableOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReadVariableOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ReadVariableOptionsBuilder {
  typedef ReadVariableOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ReadVariableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReadVariableOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReadVariableOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ReadVariableOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AssignVariableOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return AssignVariableOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct AssignVariableOptionsBuilder {
  typedef AssignVariableOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit AssignVariableOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AssignVariableOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AssignVariableOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AssignVariableOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct RandomOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RandomOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RandomOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEED = 4,
    VT_SEED2 = 6
  };
  int64_t seed() const {
    return GetField<int64_t>(VT_SEED, 0);
  }
  bool mutate_seed(int64_t _seed = 0) {
    return SetField<int64_t>(VT_SEED, _seed, 0);
  }
  int64_t seed2() const {
    return GetField<int64_t>(VT_SEED2, 0);
  }
  bool mutate_seed2(int64_t _seed2 = 0) {
    return SetField<int64_t>(VT_SEED2, _seed2, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_SEED, 8) &&
           VerifyField<int64_t>(verifier, VT_SEED2, 8) &&
           verifier.EndTable();
  }
};

struct RandomOptionsBuilder {
  typedef RandomOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seed(int64_t seed) {
    fbb_.AddElement<int64_t>(RandomOptions::VT_SEED, seed, 0);
  }
  void add_seed2(int64_t seed2) {
    fbb_.AddElement<int64_t>(RandomOptions::VT_SEED2, seed2, 0);
  }
  explicit RandomOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RandomOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RandomOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RandomOptions> CreateRandomOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t seed = 0,
    int64_t seed2 = 0) {
  RandomOptionsBuilder builder_(_fbb);
  builder_.add_seed2(seed2);
  builder_.add_seed(seed);
  return builder_.Finish();
}

struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BucketizeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BucketizeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOUNDARIES = 4
  };
  const ::flatbuffers::Vector<float> *boundaries() const {
    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_BOUNDARIES);
  }
  ::flatbuffers::Vector<float> *mutable_boundaries() {
    return GetPointer<::flatbuffers::Vector<float> *>(VT_BOUNDARIES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_BOUNDARIES) &&
           verifier.VerifyVector(boundaries()) &&
           verifier.EndTable();
  }
};

struct BucketizeOptionsBuilder {
  typedef BucketizeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_boundaries(::flatbuffers::Offset<::flatbuffers::Vector<float>> boundaries) {
    fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries);
  }
  explicit BucketizeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BucketizeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BucketizeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<float>> boundaries = 0) {
  BucketizeOptionsBuilder builder_(_fbb);
  builder_.add_boundaries(boundaries);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<float> *boundaries = nullptr) {
  auto boundaries__ = boundaries ? _fbb.CreateVector<float>(*boundaries) : 0;
  return tflite::CreateBucketizeOptions(
      _fbb,
      boundaries__);
}

struct GeluOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GeluOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return GeluOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_APPROXIMATE = 4
  };
  bool approximate() const {
    return GetField<uint8_t>(VT_APPROXIMATE, 0) != 0;
  }
  bool mutate_approximate(bool _approximate = 0) {
    return SetField<uint8_t>(VT_APPROXIMATE, static_cast<uint8_t>(_approximate), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_APPROXIMATE, 1) &&
           verifier.EndTable();
  }
};

struct GeluOptionsBuilder {
  typedef GeluOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_approximate(bool approximate) {
    fbb_.AddElement<uint8_t>(GeluOptions::VT_APPROXIMATE, static_cast<uint8_t>(approximate), 0);
  }
  explicit GeluOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GeluOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GeluOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<GeluOptions> CreateGeluOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool approximate = false) {
  GeluOptionsBuilder builder_(_fbb);
  builder_.add_approximate(approximate);
  return builder_.Finish();
}

struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DynamicUpdateSliceOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DynamicUpdateSliceOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct DynamicUpdateSliceOptionsBuilder {
  typedef DynamicUpdateSliceOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit DynamicUpdateSliceOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DynamicUpdateSliceOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  DynamicUpdateSliceOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnsortedSegmentProdOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnsortedSegmentProdOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct UnsortedSegmentProdOptionsBuilder {
  typedef UnsortedSegmentProdOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit UnsortedSegmentProdOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnsortedSegmentProdOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  UnsortedSegmentProdOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnsortedSegmentMaxOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnsortedSegmentMaxOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct UnsortedSegmentMaxOptionsBuilder {
  typedef UnsortedSegmentMaxOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit UnsortedSegmentMaxOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnsortedSegmentMaxOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  UnsortedSegmentMaxOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnsortedSegmentSumOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnsortedSegmentSumOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct UnsortedSegmentSumOptionsBuilder {
  typedef UnsortedSegmentSumOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit UnsortedSegmentSumOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnsortedSegmentSumOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  UnsortedSegmentSumOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ATan2Options FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ATan2OptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ATan2OptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ATan2OptionsBuilder {
  typedef ATan2Options Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit ATan2OptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ATan2Options> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ATan2Options>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ATan2Options> CreateATan2Options(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ATan2OptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct UnsortedSegmentMinOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnsortedSegmentMinOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return UnsortedSegmentMinOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct UnsortedSegmentMinOptionsBuilder {
  typedef UnsortedSegmentMinOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit UnsortedSegmentMinOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnsortedSegmentMinOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnsortedSegmentMinOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  UnsortedSegmentMinOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct SignOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SignOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SignOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct SignOptionsBuilder {
  typedef SignOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit SignOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SignOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SignOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SignOptions> CreateSignOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  SignOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BitcastOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BitcastOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BitcastOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct BitcastOptionsBuilder {
  typedef BitcastOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit BitcastOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BitcastOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BitcastOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BitcastOptions> CreateBitcastOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  BitcastOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct BitwiseXorOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BitwiseXorOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BitwiseXorOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct BitwiseXorOptionsBuilder {
  typedef BitwiseXorOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit BitwiseXorOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BitwiseXorOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BitwiseXorOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BitwiseXorOptions> CreateBitwiseXorOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  BitwiseXorOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct RightShiftOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RightShiftOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return RightShiftOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct RightShiftOptionsBuilder {
  typedef RightShiftOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit RightShiftOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RightShiftOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RightShiftOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<RightShiftOptions> CreateRightShiftOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  RightShiftOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct DilateOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DilateOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return DilateOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct DilateOptionsBuilder {
  typedef DilateOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit DilateOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DilateOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DilateOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DilateOptions> CreateDilateOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  DilateOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ReduceWindowOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReduceWindowOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReduceWindowOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REDUCE_FUNCTION = 4
  };
  tflite::ReduceWindowFunction reduce_function() const {
    return static_cast<tflite::ReduceWindowFunction>(GetField<int32_t>(VT_REDUCE_FUNCTION, 0));
  }
  bool mutate_reduce_function(tflite::ReduceWindowFunction _reduce_function = static_cast<tflite::ReduceWindowFunction>(0)) {
    return SetField<int32_t>(VT_REDUCE_FUNCTION, static_cast<int32_t>(_reduce_function), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_REDUCE_FUNCTION, 4) &&
           verifier.EndTable();
  }
};

struct ReduceWindowOptionsBuilder {
  typedef ReduceWindowOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_reduce_function(tflite::ReduceWindowFunction reduce_function) {
    fbb_.AddElement<int32_t>(ReduceWindowOptions::VT_REDUCE_FUNCTION, static_cast<int32_t>(reduce_function), 0);
  }
  explicit ReduceWindowOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReduceWindowOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReduceWindowOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ReduceWindowOptions> CreateReduceWindowOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tflite::ReduceWindowFunction reduce_function = tflite::ReduceWindowFunction::UNSUPPORTED) {
  ReduceWindowOptionsBuilder builder_(_fbb);
  builder_.add_reduce_function(reduce_function);
  return builder_.Finish();
}

struct OperatorCode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OperatorCodeBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return OperatorCodeTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DEPRECATED_BUILTIN_CODE = 4,
    VT_CUSTOM_CODE = 6,
    VT_VERSION = 8,
    VT_BUILTIN_CODE = 10
  };
  int8_t deprecated_builtin_code() const {
    return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0);
  }
  bool mutate_deprecated_builtin_code(int8_t _deprecated_builtin_code = 0) {
    return SetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, _deprecated_builtin_code, 0);
  }
  const ::flatbuffers::String *custom_code() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CUSTOM_CODE);
  }
  ::flatbuffers::String *mutable_custom_code() {
    return GetPointer<::flatbuffers::String *>(VT_CUSTOM_CODE);
  }
  int32_t version() const {
    return GetField<int32_t>(VT_VERSION, 1);
  }
  bool mutate_version(int32_t _version = 1) {
    return SetField<int32_t>(VT_VERSION, _version, 1);
  }
  tflite::BuiltinOperator builtin_code() const {
    return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
  }
  bool mutate_builtin_code(tflite::BuiltinOperator _builtin_code = static_cast<tflite::BuiltinOperator>(0)) {
    return SetField<int32_t>(VT_BUILTIN_CODE, static_cast<int32_t>(_builtin_code), 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE, 1) &&
           VerifyOffset(verifier, VT_CUSTOM_CODE) &&
           verifier.VerifyString(custom_code()) &&
           VerifyField<int32_t>(verifier, VT_VERSION, 4) &&
           VerifyField<int32_t>(verifier, VT_BUILTIN_CODE, 4) &&
           verifier.EndTable();
  }
};

struct OperatorCodeBuilder {
  typedef OperatorCode Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_deprecated_builtin_code(int8_t deprecated_builtin_code) {
    fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
  }
  void add_custom_code(::flatbuffers::Offset<::flatbuffers::String> custom_code) {
    fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
  }
  void add_version(int32_t version) {
    fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
  }
  void add_builtin_code(tflite::BuiltinOperator builtin_code) {
    fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
  }
  explicit OperatorCodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<OperatorCode> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<OperatorCode>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<OperatorCode> CreateOperatorCode(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int8_t deprecated_builtin_code = 0,
    ::flatbuffers::Offset<::flatbuffers::String> custom_code = 0,
    int32_t version = 1,
    tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator::ADD) {
  OperatorCodeBuilder builder_(_fbb);
  builder_.add_builtin_code(builtin_code);
  builder_.add_version(version);
  builder_.add_custom_code(custom_code);
  builder_.add_deprecated_builtin_code(deprecated_builtin_code);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int8_t deprecated_builtin_code = 0,
    const char *custom_code = nullptr,
    int32_t version = 1,
    tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator::ADD) {
  auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
  return tflite::CreateOperatorCode(
      _fbb,
      deprecated_builtin_code,
      custom_code__,
      version,
      builtin_code);
}

struct StableHLOCompositeOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StableHLOCompositeOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StableHLOCompositeOptionsTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_DECOMPOSITION_SUBGRAPH_INDEX = 6,
    VT_COMPOSITE_ATTRIBUTES = 8,
    VT_COMPOSITE_ATTRIBUTES_FORMAT = 10,
    VT_VERSION = 12
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  int32_t decomposition_subgraph_index() const {
    return GetField<int32_t>(VT_DECOMPOSITION_SUBGRAPH_INDEX, 0);
  }
  bool mutate_decomposition_subgraph_index(int32_t _decomposition_subgraph_index = 0) {
    return SetField<int32_t>(VT_DECOMPOSITION_SUBGRAPH_INDEX, _decomposition_subgraph_index, 0);
  }
  const ::flatbuffers::Vector<uint8_t> *composite_attributes() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_COMPOSITE_ATTRIBUTES);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_composite_attributes() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_COMPOSITE_ATTRIBUTES);
  }
  tflite::CustomOptionsFormat composite_attributes_format() const {
    return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_COMPOSITE_ATTRIBUTES_FORMAT, 0));
  }
  bool mutate_composite_attributes_format(tflite::CustomOptionsFormat _composite_attributes_format = static_cast<tflite::CustomOptionsFormat>(0)) {
    return SetField<int8_t>(VT_COMPOSITE_ATTRIBUTES_FORMAT, static_cast<int8_t>(_composite_attributes_format), 0);
  }
  int32_t version() const {
    return GetField<int32_t>(VT_VERSION, 0);
  }
  bool mutate_version(int32_t _version = 0) {
    return SetField<int32_t>(VT_VERSION, _version, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<int32_t>(verifier, VT_DECOMPOSITION_SUBGRAPH_INDEX, 4) &&
           VerifyOffset(verifier, VT_COMPOSITE_ATTRIBUTES) &&
           verifier.VerifyVector(composite_attributes()) &&
           VerifyField<int8_t>(verifier, VT_COMPOSITE_ATTRIBUTES_FORMAT, 1) &&
           VerifyField<int32_t>(verifier, VT_VERSION, 4) &&
           verifier.EndTable();
  }
};

struct StableHLOCompositeOptionsBuilder {
  typedef StableHLOCompositeOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(StableHLOCompositeOptions::VT_NAME, name);
  }
  void add_decomposition_subgraph_index(int32_t decomposition_subgraph_index) {
    fbb_.AddElement<int32_t>(StableHLOCompositeOptions::VT_DECOMPOSITION_SUBGRAPH_INDEX, decomposition_subgraph_index, 0);
  }
  void add_composite_attributes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> composite_attributes) {
    fbb_.AddOffset(StableHLOCompositeOptions::VT_COMPOSITE_ATTRIBUTES, composite_attributes);
  }
  void add_composite_attributes_format(tflite::CustomOptionsFormat composite_attributes_format) {
    fbb_.AddElement<int8_t>(StableHLOCompositeOptions::VT_COMPOSITE_ATTRIBUTES_FORMAT, static_cast<int8_t>(composite_attributes_format), 0);
  }
  void add_version(int32_t version) {
    fbb_.AddElement<int32_t>(StableHLOCompositeOptions::VT_VERSION, version, 0);
  }
  explicit StableHLOCompositeOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StableHLOCompositeOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StableHLOCompositeOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StableHLOCompositeOptions> CreateStableHLOCompositeOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    int32_t decomposition_subgraph_index = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> composite_attributes = 0,
    tflite::CustomOptionsFormat composite_attributes_format = tflite::CustomOptionsFormat::FLEXBUFFERS,
    int32_t version = 0) {
  StableHLOCompositeOptionsBuilder builder_(_fbb);
  builder_.add_version(version);
  builder_.add_composite_attributes(composite_attributes);
  builder_.add_decomposition_subgraph_index(decomposition_subgraph_index);
  builder_.add_name(name);
  builder_.add_composite_attributes_format(composite_attributes_format);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<StableHLOCompositeOptions> CreateStableHLOCompositeOptionsDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    int32_t decomposition_subgraph_index = 0,
    const std::vector<uint8_t> *composite_attributes = nullptr,
    tflite::CustomOptionsFormat composite_attributes_format = tflite::CustomOptionsFormat::FLEXBUFFERS,
    int32_t version = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto composite_attributes__ = composite_attributes ? _fbb.CreateVector<uint8_t>(*composite_attributes) : 0;
  return tflite::CreateStableHLOCompositeOptions(
      _fbb,
      name__,
      decomposition_subgraph_index,
      composite_attributes__,
      composite_attributes_format,
      version);
}

struct StablehloShiftLeftOptions FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StablehloShiftLeftOptionsBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return StablehloShiftLeftOptionsTypeTable();
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct StablehloShiftLeftOptionsBuilder {
  typedef StablehloShiftLeftOptions Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit StablehloShiftLeftOptionsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<StablehloShiftLeftOptions> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<StablehloShiftLeftOptions>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<StablehloShiftLeftOptions> CreateStablehloShiftLeftOptions(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  StablehloShiftLeftOptionsBuilder builder_(_fbb);
  return builder_.Finish();
}

struct Operator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OperatorBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return OperatorTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OPCODE_INDEX = 4,
    VT_INPUTS = 6,
    VT_OUTPUTS = 8,
    VT_BUILTIN_OPTIONS_TYPE = 10,
    VT_BUILTIN_OPTIONS = 12,
    VT_CUSTOM_OPTIONS = 14,
    VT_CUSTOM_OPTIONS_FORMAT = 16,
    VT_MUTATING_VARIABLE_INPUTS = 18,
    VT_INTERMEDIATES = 20,
    VT_LARGE_CUSTOM_OPTIONS_OFFSET = 22,
    VT_LARGE_CUSTOM_OPTIONS_SIZE = 24,
    VT_BUILTIN_OPTIONS_2_TYPE = 26,
    VT_BUILTIN_OPTIONS_2 = 28,
    VT_DEBUG_METADATA_INDEX = 30
  };
  uint32_t opcode_index() const {
    return GetField<uint32_t>(VT_OPCODE_INDEX, 0);
  }
  bool mutate_opcode_index(uint32_t _opcode_index = 0) {
    return SetField<uint32_t>(VT_OPCODE_INDEX, _opcode_index, 0);
  }
  const ::flatbuffers::Vector<int32_t> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_inputs() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<int32_t> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_outputs() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
  }
  tflite::BuiltinOptions builtin_options_type() const {
    return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
  }
  const void *builtin_options() const {
    return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
  }
  template<typename T> const T *builtin_options_as() const;
  const tflite::Conv2DOptions *builtin_options_as_Conv2DOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::Conv2DOptions ? static_cast<const tflite::Conv2DOptions *>(builtin_options()) : nullptr;
  }
  const tflite::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DepthwiseConv2DOptions ? static_cast<const tflite::DepthwiseConv2DOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ConcatEmbeddingsOptions ? static_cast<const tflite::ConcatEmbeddingsOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LSHProjectionOptions ? static_cast<const tflite::LSHProjectionOptions *>(builtin_options()) : nullptr;
  }
  const tflite::Pool2DOptions *builtin_options_as_Pool2DOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::Pool2DOptions ? static_cast<const tflite::Pool2DOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SVDFOptions *builtin_options_as_SVDFOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SVDFOptions ? static_cast<const tflite::SVDFOptions *>(builtin_options()) : nullptr;
  }
  const tflite::RNNOptions *builtin_options_as_RNNOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::RNNOptions ? static_cast<const tflite::RNNOptions *>(builtin_options()) : nullptr;
  }
  const tflite::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::FullyConnectedOptions ? static_cast<const tflite::FullyConnectedOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SoftmaxOptions ? static_cast<const tflite::SoftmaxOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ConcatenationOptions ? static_cast<const tflite::ConcatenationOptions *>(builtin_options()) : nullptr;
  }
  const tflite::AddOptions *builtin_options_as_AddOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::AddOptions ? static_cast<const tflite::AddOptions *>(builtin_options()) : nullptr;
  }
  const tflite::L2NormOptions *builtin_options_as_L2NormOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::L2NormOptions ? static_cast<const tflite::L2NormOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LocalResponseNormalizationOptions ? static_cast<const tflite::LocalResponseNormalizationOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LSTMOptions *builtin_options_as_LSTMOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LSTMOptions ? static_cast<const tflite::LSTMOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ResizeBilinearOptions ? static_cast<const tflite::ResizeBilinearOptions *>(builtin_options()) : nullptr;
  }
  const tflite::CallOptions *builtin_options_as_CallOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::CallOptions ? static_cast<const tflite::CallOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ReshapeOptions *builtin_options_as_ReshapeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ReshapeOptions ? static_cast<const tflite::ReshapeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SkipGramOptions *builtin_options_as_SkipGramOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SkipGramOptions ? static_cast<const tflite::SkipGramOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SpaceToDepthOptions ? static_cast<const tflite::SpaceToDepthOptions *>(builtin_options()) : nullptr;
  }
  const tflite::EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::EmbeddingLookupSparseOptions ? static_cast<const tflite::EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr;
  }
  const tflite::MulOptions *builtin_options_as_MulOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::MulOptions ? static_cast<const tflite::MulOptions *>(builtin_options()) : nullptr;
  }
  const tflite::PadOptions *builtin_options_as_PadOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::PadOptions ? static_cast<const tflite::PadOptions *>(builtin_options()) : nullptr;
  }
  const tflite::GatherOptions *builtin_options_as_GatherOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::GatherOptions ? static_cast<const tflite::GatherOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BatchToSpaceNDOptions ? static_cast<const tflite::BatchToSpaceNDOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SpaceToBatchNDOptions ? static_cast<const tflite::SpaceToBatchNDOptions *>(builtin_options()) : nullptr;
  }
  const tflite::TransposeOptions *builtin_options_as_TransposeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::TransposeOptions ? static_cast<const tflite::TransposeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ReducerOptions *builtin_options_as_ReducerOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ReducerOptions ? static_cast<const tflite::ReducerOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SubOptions *builtin_options_as_SubOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SubOptions ? static_cast<const tflite::SubOptions *>(builtin_options()) : nullptr;
  }
  const tflite::DivOptions *builtin_options_as_DivOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DivOptions ? static_cast<const tflite::DivOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SqueezeOptions *builtin_options_as_SqueezeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SqueezeOptions ? static_cast<const tflite::SqueezeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SequenceRNNOptions ? static_cast<const tflite::SequenceRNNOptions *>(builtin_options()) : nullptr;
  }
  const tflite::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::StridedSliceOptions ? static_cast<const tflite::StridedSliceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ExpOptions *builtin_options_as_ExpOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ExpOptions ? static_cast<const tflite::ExpOptions *>(builtin_options()) : nullptr;
  }
  const tflite::TopKV2Options *builtin_options_as_TopKV2Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::TopKV2Options ? static_cast<const tflite::TopKV2Options *>(builtin_options()) : nullptr;
  }
  const tflite::SplitOptions *builtin_options_as_SplitOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SplitOptions ? static_cast<const tflite::SplitOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LogSoftmaxOptions ? static_cast<const tflite::LogSoftmaxOptions *>(builtin_options()) : nullptr;
  }
  const tflite::CastOptions *builtin_options_as_CastOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::CastOptions ? static_cast<const tflite::CastOptions *>(builtin_options()) : nullptr;
  }
  const tflite::DequantizeOptions *builtin_options_as_DequantizeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DequantizeOptions ? static_cast<const tflite::DequantizeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::MaximumMinimumOptions ? static_cast<const tflite::MaximumMinimumOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ArgMaxOptions ? static_cast<const tflite::ArgMaxOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LessOptions *builtin_options_as_LessOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LessOptions ? static_cast<const tflite::LessOptions *>(builtin_options()) : nullptr;
  }
  const tflite::NegOptions *builtin_options_as_NegOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::NegOptions ? static_cast<const tflite::NegOptions *>(builtin_options()) : nullptr;
  }
  const tflite::PadV2Options *builtin_options_as_PadV2Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::PadV2Options ? static_cast<const tflite::PadV2Options *>(builtin_options()) : nullptr;
  }
  const tflite::GreaterOptions *builtin_options_as_GreaterOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::GreaterOptions ? static_cast<const tflite::GreaterOptions *>(builtin_options()) : nullptr;
  }
  const tflite::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::GreaterEqualOptions ? static_cast<const tflite::GreaterEqualOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LessEqualOptions *builtin_options_as_LessEqualOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LessEqualOptions ? static_cast<const tflite::LessEqualOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SelectOptions *builtin_options_as_SelectOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SelectOptions ? static_cast<const tflite::SelectOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SliceOptions *builtin_options_as_SliceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SliceOptions ? static_cast<const tflite::SliceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::TransposeConvOptions ? static_cast<const tflite::TransposeConvOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SparseToDenseOptions ? static_cast<const tflite::SparseToDenseOptions *>(builtin_options()) : nullptr;
  }
  const tflite::TileOptions *builtin_options_as_TileOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::TileOptions ? static_cast<const tflite::TileOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ExpandDimsOptions ? static_cast<const tflite::ExpandDimsOptions *>(builtin_options()) : nullptr;
  }
  const tflite::EqualOptions *builtin_options_as_EqualOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::EqualOptions ? static_cast<const tflite::EqualOptions *>(builtin_options()) : nullptr;
  }
  const tflite::NotEqualOptions *builtin_options_as_NotEqualOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::NotEqualOptions ? static_cast<const tflite::NotEqualOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ShapeOptions *builtin_options_as_ShapeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ShapeOptions ? static_cast<const tflite::ShapeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::PowOptions *builtin_options_as_PowOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::PowOptions ? static_cast<const tflite::PowOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ArgMinOptions *builtin_options_as_ArgMinOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ArgMinOptions ? static_cast<const tflite::ArgMinOptions *>(builtin_options()) : nullptr;
  }
  const tflite::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::FakeQuantOptions ? static_cast<const tflite::FakeQuantOptions *>(builtin_options()) : nullptr;
  }
  const tflite::PackOptions *builtin_options_as_PackOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::PackOptions ? static_cast<const tflite::PackOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LogicalOrOptions ? static_cast<const tflite::LogicalOrOptions *>(builtin_options()) : nullptr;
  }
  const tflite::OneHotOptions *builtin_options_as_OneHotOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::OneHotOptions ? static_cast<const tflite::OneHotOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LogicalAndOptions ? static_cast<const tflite::LogicalAndOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LogicalNotOptions ? static_cast<const tflite::LogicalNotOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnpackOptions *builtin_options_as_UnpackOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnpackOptions ? static_cast<const tflite::UnpackOptions *>(builtin_options()) : nullptr;
  }
  const tflite::FloorDivOptions *builtin_options_as_FloorDivOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::FloorDivOptions ? static_cast<const tflite::FloorDivOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SquareOptions *builtin_options_as_SquareOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SquareOptions ? static_cast<const tflite::SquareOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ZerosLikeOptions ? static_cast<const tflite::ZerosLikeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::FillOptions *builtin_options_as_FillOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::FillOptions ? static_cast<const tflite::FillOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BidirectionalSequenceLSTMOptions *builtin_options_as_BidirectionalSequenceLSTMOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BidirectionalSequenceLSTMOptions ? static_cast<const tflite::BidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BidirectionalSequenceRNNOptions ? static_cast<const tflite::BidirectionalSequenceRNNOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnidirectionalSequenceLSTMOptions *builtin_options_as_UnidirectionalSequenceLSTMOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnidirectionalSequenceLSTMOptions ? static_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
  }
  const tflite::FloorModOptions *builtin_options_as_FloorModOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::FloorModOptions ? static_cast<const tflite::FloorModOptions *>(builtin_options()) : nullptr;
  }
  const tflite::RangeOptions *builtin_options_as_RangeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::RangeOptions ? static_cast<const tflite::RangeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ResizeNearestNeighborOptions ? static_cast<const tflite::ResizeNearestNeighborOptions *>(builtin_options()) : nullptr;
  }
  const tflite::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::LeakyReluOptions ? static_cast<const tflite::LeakyReluOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SquaredDifferenceOptions ? static_cast<const tflite::SquaredDifferenceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::MirrorPadOptions ? static_cast<const tflite::MirrorPadOptions *>(builtin_options()) : nullptr;
  }
  const tflite::AbsOptions *builtin_options_as_AbsOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::AbsOptions ? static_cast<const tflite::AbsOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SplitVOptions *builtin_options_as_SplitVOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SplitVOptions ? static_cast<const tflite::SplitVOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UniqueOptions *builtin_options_as_UniqueOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UniqueOptions ? static_cast<const tflite::UniqueOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ReverseV2Options *builtin_options_as_ReverseV2Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::ReverseV2Options ? static_cast<const tflite::ReverseV2Options *>(builtin_options()) : nullptr;
  }
  const tflite::AddNOptions *builtin_options_as_AddNOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::AddNOptions ? static_cast<const tflite::AddNOptions *>(builtin_options()) : nullptr;
  }
  const tflite::GatherNdOptions *builtin_options_as_GatherNdOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::GatherNdOptions ? static_cast<const tflite::GatherNdOptions *>(builtin_options()) : nullptr;
  }
  const tflite::CosOptions *builtin_options_as_CosOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::CosOptions ? static_cast<const tflite::CosOptions *>(builtin_options()) : nullptr;
  }
  const tflite::WhereOptions *builtin_options_as_WhereOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::WhereOptions ? static_cast<const tflite::WhereOptions *>(builtin_options()) : nullptr;
  }
  const tflite::RankOptions *builtin_options_as_RankOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::RankOptions ? static_cast<const tflite::RankOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ReverseSequenceOptions ? static_cast<const tflite::ReverseSequenceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::MatrixDiagOptions ? static_cast<const tflite::MatrixDiagOptions *>(builtin_options()) : nullptr;
  }
  const tflite::QuantizeOptions *builtin_options_as_QuantizeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::QuantizeOptions ? static_cast<const tflite::QuantizeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::MatrixSetDiagOptions ? static_cast<const tflite::MatrixSetDiagOptions *>(builtin_options()) : nullptr;
  }
  const tflite::HardSwishOptions *builtin_options_as_HardSwishOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::HardSwishOptions ? static_cast<const tflite::HardSwishOptions *>(builtin_options()) : nullptr;
  }
  const tflite::IfOptions *builtin_options_as_IfOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::IfOptions ? static_cast<const tflite::IfOptions *>(builtin_options()) : nullptr;
  }
  const tflite::WhileOptions *builtin_options_as_WhileOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::WhileOptions ? static_cast<const tflite::WhileOptions *>(builtin_options()) : nullptr;
  }
  const tflite::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DepthToSpaceOptions ? static_cast<const tflite::DepthToSpaceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::NonMaxSuppressionV4Options ? static_cast<const tflite::NonMaxSuppressionV4Options *>(builtin_options()) : nullptr;
  }
  const tflite::NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::NonMaxSuppressionV5Options ? static_cast<const tflite::NonMaxSuppressionV5Options *>(builtin_options()) : nullptr;
  }
  const tflite::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ScatterNdOptions ? static_cast<const tflite::ScatterNdOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SelectV2Options *builtin_options_as_SelectV2Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::SelectV2Options ? static_cast<const tflite::SelectV2Options *>(builtin_options()) : nullptr;
  }
  const tflite::DensifyOptions *builtin_options_as_DensifyOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DensifyOptions ? static_cast<const tflite::DensifyOptions *>(builtin_options()) : nullptr;
  }
  const tflite::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SegmentSumOptions ? static_cast<const tflite::SegmentSumOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BatchMatMulOptions ? static_cast<const tflite::BatchMatMulOptions *>(builtin_options()) : nullptr;
  }
  const tflite::CumsumOptions *builtin_options_as_CumsumOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::CumsumOptions ? static_cast<const tflite::CumsumOptions *>(builtin_options()) : nullptr;
  }
  const tflite::CallOnceOptions *builtin_options_as_CallOnceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::CallOnceOptions ? static_cast<const tflite::CallOnceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BroadcastToOptions *builtin_options_as_BroadcastToOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BroadcastToOptions ? static_cast<const tflite::BroadcastToOptions *>(builtin_options()) : nullptr;
  }
  const tflite::Rfft2dOptions *builtin_options_as_Rfft2dOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::Rfft2dOptions ? static_cast<const tflite::Rfft2dOptions *>(builtin_options()) : nullptr;
  }
  const tflite::Conv3DOptions *builtin_options_as_Conv3DOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::Conv3DOptions ? static_cast<const tflite::Conv3DOptions *>(builtin_options()) : nullptr;
  }
  const tflite::HashtableOptions *builtin_options_as_HashtableOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::HashtableOptions ? static_cast<const tflite::HashtableOptions *>(builtin_options()) : nullptr;
  }
  const tflite::HashtableFindOptions *builtin_options_as_HashtableFindOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::HashtableFindOptions ? static_cast<const tflite::HashtableFindOptions *>(builtin_options()) : nullptr;
  }
  const tflite::HashtableImportOptions *builtin_options_as_HashtableImportOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::HashtableImportOptions ? static_cast<const tflite::HashtableImportOptions *>(builtin_options()) : nullptr;
  }
  const tflite::HashtableSizeOptions *builtin_options_as_HashtableSizeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::HashtableSizeOptions ? static_cast<const tflite::HashtableSizeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::VarHandleOptions *builtin_options_as_VarHandleOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::VarHandleOptions ? static_cast<const tflite::VarHandleOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ReadVariableOptions *builtin_options_as_ReadVariableOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::ReadVariableOptions ? static_cast<const tflite::ReadVariableOptions *>(builtin_options()) : nullptr;
  }
  const tflite::AssignVariableOptions *builtin_options_as_AssignVariableOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::AssignVariableOptions ? static_cast<const tflite::AssignVariableOptions *>(builtin_options()) : nullptr;
  }
  const tflite::RandomOptions *builtin_options_as_RandomOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::RandomOptions ? static_cast<const tflite::RandomOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BucketizeOptions *builtin_options_as_BucketizeOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BucketizeOptions ? static_cast<const tflite::BucketizeOptions *>(builtin_options()) : nullptr;
  }
  const tflite::GeluOptions *builtin_options_as_GeluOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::GeluOptions ? static_cast<const tflite::GeluOptions *>(builtin_options()) : nullptr;
  }
  const tflite::DynamicUpdateSliceOptions *builtin_options_as_DynamicUpdateSliceOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::DynamicUpdateSliceOptions ? static_cast<const tflite::DynamicUpdateSliceOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnsortedSegmentProdOptions *builtin_options_as_UnsortedSegmentProdOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnsortedSegmentProdOptions ? static_cast<const tflite::UnsortedSegmentProdOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnsortedSegmentMaxOptions *builtin_options_as_UnsortedSegmentMaxOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnsortedSegmentMaxOptions ? static_cast<const tflite::UnsortedSegmentMaxOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnsortedSegmentMinOptions *builtin_options_as_UnsortedSegmentMinOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnsortedSegmentMinOptions ? static_cast<const tflite::UnsortedSegmentMinOptions *>(builtin_options()) : nullptr;
  }
  const tflite::UnsortedSegmentSumOptions *builtin_options_as_UnsortedSegmentSumOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::UnsortedSegmentSumOptions ? static_cast<const tflite::UnsortedSegmentSumOptions *>(builtin_options()) : nullptr;
  }
  const tflite::ATan2Options *builtin_options_as_ATan2Options() const {
    return builtin_options_type() == tflite::BuiltinOptions::ATan2Options ? static_cast<const tflite::ATan2Options *>(builtin_options()) : nullptr;
  }
  const tflite::SignOptions *builtin_options_as_SignOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::SignOptions ? static_cast<const tflite::SignOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BitcastOptions *builtin_options_as_BitcastOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BitcastOptions ? static_cast<const tflite::BitcastOptions *>(builtin_options()) : nullptr;
  }
  const tflite::BitwiseXorOptions *builtin_options_as_BitwiseXorOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::BitwiseXorOptions ? static_cast<const tflite::BitwiseXorOptions *>(builtin_options()) : nullptr;
  }
  const tflite::RightShiftOptions *builtin_options_as_RightShiftOptions() const {
    return builtin_options_type() == tflite::BuiltinOptions::RightShiftOptions ? static_cast<const tflite::RightShiftOptions *>(builtin_options()) : nullptr;
  }
  void *mutable_builtin_options() {
    return GetPointer<void *>(VT_BUILTIN_OPTIONS);
  }
  const ::flatbuffers::Vector<uint8_t> *custom_options() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_custom_options() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
  }
  tflite::CustomOptionsFormat custom_options_format() const {
    return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
  }
  bool mutate_custom_options_format(tflite::CustomOptionsFormat _custom_options_format = static_cast<tflite::CustomOptionsFormat>(0)) {
    return SetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(_custom_options_format), 0);
  }
  const ::flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_mutating_variable_inputs() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
  }
  const ::flatbuffers::Vector<int32_t> *intermediates() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
  }
  ::flatbuffers::Vector<int32_t> *mutable_intermediates() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
  }
  uint64_t large_custom_options_offset() const {
    return GetField<uint64_t>(VT_LARGE_CUSTOM_OPTIONS_OFFSET, 0);
  }
  bool mutate_large_custom_options_offset(uint64_t _large_custom_options_offset = 0) {
    return SetField<uint64_t>(VT_LARGE_CUSTOM_OPTIONS_OFFSET, _large_custom_options_offset, 0);
  }
  uint64_t large_custom_options_size() const {
    return GetField<uint64_t>(VT_LARGE_CUSTOM_OPTIONS_SIZE, 0);
  }
  bool mutate_large_custom_options_size(uint64_t _large_custom_options_size = 0) {
    return SetField<uint64_t>(VT_LARGE_CUSTOM_OPTIONS_SIZE, _large_custom_options_size, 0);
  }
  tflite::BuiltinOptions2 builtin_options_2_type() const {
    return static_cast<tflite::BuiltinOptions2>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_2_TYPE, 0));
  }
  const void *builtin_options_2() const {
    return GetPointer<const void *>(VT_BUILTIN_OPTIONS_2);
  }
  template<typename T> const T *builtin_options_2_as() const;
  const tflite::StablehloConcatenateOptions *builtin_options_2_as_StablehloConcatenateOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloConcatenateOptions ? static_cast<const tflite::StablehloConcatenateOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloBroadcastInDimOptions *builtin_options_2_as_StablehloBroadcastInDimOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloBroadcastInDimOptions ? static_cast<const tflite::StablehloBroadcastInDimOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloSliceOptions *builtin_options_2_as_StablehloSliceOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloSliceOptions ? static_cast<const tflite::StablehloSliceOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloConvolutionOptions *builtin_options_2_as_StablehloConvolutionOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloConvolutionOptions ? static_cast<const tflite::StablehloConvolutionOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloCustomCallOptions *builtin_options_2_as_StablehloCustomCallOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloCustomCallOptions ? static_cast<const tflite::StablehloCustomCallOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloReduceOptions *builtin_options_2_as_StablehloReduceOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloReduceOptions ? static_cast<const tflite::StablehloReduceOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloScatterOptions *builtin_options_2_as_StablehloScatterOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloScatterOptions ? static_cast<const tflite::StablehloScatterOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloCompareOptions *builtin_options_2_as_StablehloCompareOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloCompareOptions ? static_cast<const tflite::StablehloCompareOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloDynamicSliceOptions *builtin_options_2_as_StablehloDynamicSliceOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloDynamicSliceOptions ? static_cast<const tflite::StablehloDynamicSliceOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloPadOptions *builtin_options_2_as_StablehloPadOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloPadOptions ? static_cast<const tflite::StablehloPadOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloIotaOptions *builtin_options_2_as_StablehloIotaOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloIotaOptions ? static_cast<const tflite::StablehloIotaOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloDotGeneralOptions *builtin_options_2_as_StablehloDotGeneralOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloDotGeneralOptions ? static_cast<const tflite::StablehloDotGeneralOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloReduceWindowOptions *builtin_options_2_as_StablehloReduceWindowOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloReduceWindowOptions ? static_cast<const tflite::StablehloReduceWindowOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloSortOptions *builtin_options_2_as_StablehloSortOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloSortOptions ? static_cast<const tflite::StablehloSortOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloWhileOptions *builtin_options_2_as_StablehloWhileOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloWhileOptions ? static_cast<const tflite::StablehloWhileOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloGatherOptions *builtin_options_2_as_StablehloGatherOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloGatherOptions ? static_cast<const tflite::StablehloGatherOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloTransposeOptions *builtin_options_2_as_StablehloTransposeOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloTransposeOptions ? static_cast<const tflite::StablehloTransposeOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::DilateOptions *builtin_options_2_as_DilateOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::DilateOptions ? static_cast<const tflite::DilateOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloRngBitGeneratorOptions *builtin_options_2_as_StablehloRngBitGeneratorOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloRngBitGeneratorOptions ? static_cast<const tflite::StablehloRngBitGeneratorOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::ReduceWindowOptions *builtin_options_2_as_ReduceWindowOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::ReduceWindowOptions ? static_cast<const tflite::ReduceWindowOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StableHLOCompositeOptions *builtin_options_2_as_StableHLOCompositeOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StableHLOCompositeOptions ? static_cast<const tflite::StableHLOCompositeOptions *>(builtin_options_2()) : nullptr;
  }
  const tflite::StablehloShiftLeftOptions *builtin_options_2_as_StablehloShiftLeftOptions() const {
    return builtin_options_2_type() == tflite::BuiltinOptions2::StablehloShiftLeftOptions ? static_cast<const tflite::StablehloShiftLeftOptions *>(builtin_options_2()) : nullptr;
  }
  void *mutable_builtin_options_2() {
    return GetPointer<void *>(VT_BUILTIN_OPTIONS_2);
  }
  int32_t debug_metadata_index() const {
    return GetField<int32_t>(VT_DEBUG_METADATA_INDEX, -1);
  }
  bool mutate_debug_metadata_index(int32_t _debug_metadata_index = -1) {
    return SetField<int32_t>(VT_DEBUG_METADATA_INDEX, _debug_metadata_index, -1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX, 4) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE, 1) &&
           VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
           VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
           VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
           verifier.VerifyVector(custom_options()) &&
           VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT, 1) &&
           VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
           verifier.VerifyVector(mutating_variable_inputs()) &&
           VerifyOffset(verifier, VT_INTERMEDIATES) &&
           verifier.VerifyVector(intermediates()) &&
           VerifyField<uint64_t>(verifier, VT_LARGE_CUSTOM_OPTIONS_OFFSET, 8) &&
           VerifyField<uint64_t>(verifier, VT_LARGE_CUSTOM_OPTIONS_SIZE, 8) &&
           VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_2_TYPE, 1) &&
           VerifyOffset(verifier, VT_BUILTIN_OPTIONS_2) &&
           VerifyBuiltinOptions2(verifier, builtin_options_2(), builtin_options_2_type()) &&
           VerifyField<int32_t>(verifier, VT_DEBUG_METADATA_INDEX, 4) &&
           verifier.EndTable();
  }
};

template<> inline const tflite::Conv2DOptions *Operator::builtin_options_as<tflite::Conv2DOptions>() const {
  return builtin_options_as_Conv2DOptions();
}

template<> inline const tflite::DepthwiseConv2DOptions *Operator::builtin_options_as<tflite::DepthwiseConv2DOptions>() const {
  return builtin_options_as_DepthwiseConv2DOptions();
}

template<> inline const tflite::ConcatEmbeddingsOptions *Operator::builtin_options_as<tflite::ConcatEmbeddingsOptions>() const {
  return builtin_options_as_ConcatEmbeddingsOptions();
}

template<> inline const tflite::LSHProjectionOptions *Operator::builtin_options_as<tflite::LSHProjectionOptions>() const {
  return builtin_options_as_LSHProjectionOptions();
}

template<> inline const tflite::Pool2DOptions *Operator::builtin_options_as<tflite::Pool2DOptions>() const {
  return builtin_options_as_Pool2DOptions();
}

template<> inline const tflite::SVDFOptions *Operator::builtin_options_as<tflite::SVDFOptions>() const {
  return builtin_options_as_SVDFOptions();
}

template<> inline const tflite::RNNOptions *Operator::builtin_options_as<tflite::RNNOptions>() const {
  return builtin_options_as_RNNOptions();
}

template<> inline const tflite::FullyConnectedOptions *Operator::builtin_options_as<tflite::FullyConnectedOptions>() const {
  return builtin_options_as_FullyConnectedOptions();
}

template<> inline const tflite::SoftmaxOptions *Operator::builtin_options_as<tflite::SoftmaxOptions>() const {
  return builtin_options_as_SoftmaxOptions();
}

template<> inline const tflite::ConcatenationOptions *Operator::builtin_options_as<tflite::ConcatenationOptions>() const {
  return builtin_options_as_ConcatenationOptions();
}

template<> inline const tflite::AddOptions *Operator::builtin_options_as<tflite::AddOptions>() const {
  return builtin_options_as_AddOptions();
}

template<> inline const tflite::L2NormOptions *Operator::builtin_options_as<tflite::L2NormOptions>() const {
  return builtin_options_as_L2NormOptions();
}

template<> inline const tflite::LocalResponseNormalizationOptions *Operator::builtin_options_as<tflite::LocalResponseNormalizationOptions>() const {
  return builtin_options_as_LocalResponseNormalizationOptions();
}

template<> inline const tflite::LSTMOptions *Operator::builtin_options_as<tflite::LSTMOptions>() const {
  return builtin_options_as_LSTMOptions();
}

template<> inline const tflite::ResizeBilinearOptions *Operator::builtin_options_as<tflite::ResizeBilinearOptions>() const {
  return builtin_options_as_ResizeBilinearOptions();
}

template<> inline const tflite::CallOptions *Operator::builtin_options_as<tflite::CallOptions>() const {
  return builtin_options_as_CallOptions();
}

template<> inline const tflite::ReshapeOptions *Operator::builtin_options_as<tflite::ReshapeOptions>() const {
  return builtin_options_as_ReshapeOptions();
}

template<> inline const tflite::SkipGramOptions *Operator::builtin_options_as<tflite::SkipGramOptions>() const {
  return builtin_options_as_SkipGramOptions();
}

template<> inline const tflite::SpaceToDepthOptions *Operator::builtin_options_as<tflite::SpaceToDepthOptions>() const {
  return builtin_options_as_SpaceToDepthOptions();
}

template<> inline const tflite::EmbeddingLookupSparseOptions *Operator::builtin_options_as<tflite::EmbeddingLookupSparseOptions>() const {
  return builtin_options_as_EmbeddingLookupSparseOptions();
}

template<> inline const tflite::MulOptions *Operator::builtin_options_as<tflite::MulOptions>() const {
  return builtin_options_as_MulOptions();
}

template<> inline const tflite::PadOptions *Operator::builtin_options_as<tflite::PadOptions>() const {
  return builtin_options_as_PadOptions();
}

template<> inline const tflite::GatherOptions *Operator::builtin_options_as<tflite::GatherOptions>() const {
  return builtin_options_as_GatherOptions();
}

template<> inline const tflite::BatchToSpaceNDOptions *Operator::builtin_options_as<tflite::BatchToSpaceNDOptions>() const {
  return builtin_options_as_BatchToSpaceNDOptions();
}

template<> inline const tflite::SpaceToBatchNDOptions *Operator::builtin_options_as<tflite::SpaceToBatchNDOptions>() const {
  return builtin_options_as_SpaceToBatchNDOptions();
}

template<> inline const tflite::TransposeOptions *Operator::builtin_options_as<tflite::TransposeOptions>() const {
  return builtin_options_as_TransposeOptions();
}

template<> inline const tflite::ReducerOptions *Operator::builtin_options_as<tflite::ReducerOptions>() const {
  return builtin_options_as_ReducerOptions();
}

template<> inline const tflite::SubOptions *Operator::builtin_options_as<tflite::SubOptions>() const {
  return builtin_options_as_SubOptions();
}

template<> inline const tflite::DivOptions *Operator::builtin_options_as<tflite::DivOptions>() const {
  return builtin_options_as_DivOptions();
}

template<> inline const tflite::SqueezeOptions *Operator::builtin_options_as<tflite::SqueezeOptions>() const {
  return builtin_options_as_SqueezeOptions();
}

template<> inline const tflite::SequenceRNNOptions *Operator::builtin_options_as<tflite::SequenceRNNOptions>() const {
  return builtin_options_as_SequenceRNNOptions();
}

template<> inline const tflite::StridedSliceOptions *Operator::builtin_options_as<tflite::StridedSliceOptions>() const {
  return builtin_options_as_StridedSliceOptions();
}

template<> inline const tflite::ExpOptions *Operator::builtin_options_as<tflite::ExpOptions>() const {
  return builtin_options_as_ExpOptions();
}

template<> inline const tflite::TopKV2Options *Operator::builtin_options_as<tflite::TopKV2Options>() const {
  return builtin_options_as_TopKV2Options();
}

template<> inline const tflite::SplitOptions *Operator::builtin_options_as<tflite::SplitOptions>() const {
  return builtin_options_as_SplitOptions();
}

template<> inline const tflite::LogSoftmaxOptions *Operator::builtin_options_as<tflite::LogSoftmaxOptions>() const {
  return builtin_options_as_LogSoftmaxOptions();
}

template<> inline const tflite::CastOptions *Operator::builtin_options_as<tflite::CastOptions>() const {
  return builtin_options_as_CastOptions();
}

template<> inline const tflite::DequantizeOptions *Operator::builtin_options_as<tflite::DequantizeOptions>() const {
  return builtin_options_as_DequantizeOptions();
}

template<> inline const tflite::MaximumMinimumOptions *Operator::builtin_options_as<tflite::MaximumMinimumOptions>() const {
  return builtin_options_as_MaximumMinimumOptions();
}

template<> inline const tflite::ArgMaxOptions *Operator::builtin_options_as<tflite::ArgMaxOptions>() const {
  return builtin_options_as_ArgMaxOptions();
}

template<> inline const tflite::LessOptions *Operator::builtin_options_as<tflite::LessOptions>() const {
  return builtin_options_as_LessOptions();
}

template<> inline const tflite::NegOptions *Operator::builtin_options_as<tflite::NegOptions>() const {
  return builtin_options_as_NegOptions();
}

template<> inline const tflite::PadV2Options *Operator::builtin_options_as<tflite::PadV2Options>() const {
  return builtin_options_as_PadV2Options();
}

template<> inline const tflite::GreaterOptions *Operator::builtin_options_as<tflite::GreaterOptions>() const {
  return builtin_options_as_GreaterOptions();
}

template<> inline const tflite::GreaterEqualOptions *Operator::builtin_options_as<tflite::GreaterEqualOptions>() const {
  return builtin_options_as_GreaterEqualOptions();
}

template<> inline const tflite::LessEqualOptions *Operator::builtin_options_as<tflite::LessEqualOptions>() const {
  return builtin_options_as_LessEqualOptions();
}

template<> inline const tflite::SelectOptions *Operator::builtin_options_as<tflite::SelectOptions>() const {
  return builtin_options_as_SelectOptions();
}

template<> inline const tflite::SliceOptions *Operator::builtin_options_as<tflite::SliceOptions>() const {
  return builtin_options_as_SliceOptions();
}

template<> inline const tflite::TransposeConvOptions *Operator::builtin_options_as<tflite::TransposeConvOptions>() const {
  return builtin_options_as_TransposeConvOptions();
}

template<> inline const tflite::SparseToDenseOptions *Operator::builtin_options_as<tflite::SparseToDenseOptions>() const {
  return builtin_options_as_SparseToDenseOptions();
}

template<> inline const tflite::TileOptions *Operator::builtin_options_as<tflite::TileOptions>() const {
  return builtin_options_as_TileOptions();
}

template<> inline const tflite::ExpandDimsOptions *Operator::builtin_options_as<tflite::ExpandDimsOptions>() const {
  return builtin_options_as_ExpandDimsOptions();
}

template<> inline const tflite::EqualOptions *Operator::builtin_options_as<tflite::EqualOptions>() const {
  return builtin_options_as_EqualOptions();
}

template<> inline const tflite::NotEqualOptions *Operator::builtin_options_as<tflite::NotEqualOptions>() const {
  return builtin_options_as_NotEqualOptions();
}

template<> inline const tflite::ShapeOptions *Operator::builtin_options_as<tflite::ShapeOptions>() const {
  return builtin_options_as_ShapeOptions();
}

template<> inline const tflite::PowOptions *Operator::builtin_options_as<tflite::PowOptions>() const {
  return builtin_options_as_PowOptions();
}

template<> inline const tflite::ArgMinOptions *Operator::builtin_options_as<tflite::ArgMinOptions>() const {
  return builtin_options_as_ArgMinOptions();
}

template<> inline const tflite::FakeQuantOptions *Operator::builtin_options_as<tflite::FakeQuantOptions>() const {
  return builtin_options_as_FakeQuantOptions();
}

template<> inline const tflite::PackOptions *Operator::builtin_options_as<tflite::PackOptions>() const {
  return builtin_options_as_PackOptions();
}

template<> inline const tflite::LogicalOrOptions *Operator::builtin_options_as<tflite::LogicalOrOptions>() const {
  return builtin_options_as_LogicalOrOptions();
}

template<> inline const tflite::OneHotOptions *Operator::builtin_options_as<tflite::OneHotOptions>() const {
  return builtin_options_as_OneHotOptions();
}

template<> inline const tflite::LogicalAndOptions *Operator::builtin_options_as<tflite::LogicalAndOptions>() const {
  return builtin_options_as_LogicalAndOptions();
}

template<> inline const tflite::LogicalNotOptions *Operator::builtin_options_as<tflite::LogicalNotOptions>() const {
  return builtin_options_as_LogicalNotOptions();
}

template<> inline const tflite::UnpackOptions *Operator::builtin_options_as<tflite::UnpackOptions>() const {
  return builtin_options_as_UnpackOptions();
}

template<> inline const tflite::FloorDivOptions *Operator::builtin_options_as<tflite::FloorDivOptions>() const {
  return builtin_options_as_FloorDivOptions();
}

template<> inline const tflite::SquareOptions *Operator::builtin_options_as<tflite::SquareOptions>() const {
  return builtin_options_as_SquareOptions();
}

template<> inline const tflite::ZerosLikeOptions *Operator::builtin_options_as<tflite::ZerosLikeOptions>() const {
  return builtin_options_as_ZerosLikeOptions();
}

template<> inline const tflite::FillOptions *Operator::builtin_options_as<tflite::FillOptions>() const {
  return builtin_options_as_FillOptions();
}

template<> inline const tflite::BidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceLSTMOptions>() const {
  return builtin_options_as_BidirectionalSequenceLSTMOptions();
}

template<> inline const tflite::BidirectionalSequenceRNNOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceRNNOptions>() const {
  return builtin_options_as_BidirectionalSequenceRNNOptions();
}

template<> inline const tflite::UnidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::UnidirectionalSequenceLSTMOptions>() const {
  return builtin_options_as_UnidirectionalSequenceLSTMOptions();
}

template<> inline const tflite::FloorModOptions *Operator::builtin_options_as<tflite::FloorModOptions>() const {
  return builtin_options_as_FloorModOptions();
}

template<> inline const tflite::RangeOptions *Operator::builtin_options_as<tflite::RangeOptions>() const {
  return builtin_options_as_RangeOptions();
}

template<> inline const tflite::ResizeNearestNeighborOptions *Operator::builtin_options_as<tflite::ResizeNearestNeighborOptions>() const {
  return builtin_options_as_ResizeNearestNeighborOptions();
}

template<> inline const tflite::LeakyReluOptions *Operator::builtin_options_as<tflite::LeakyReluOptions>() const {
  return builtin_options_as_LeakyReluOptions();
}

template<> inline const tflite::SquaredDifferenceOptions *Operator::builtin_options_as<tflite::SquaredDifferenceOptions>() const {
  return builtin_options_as_SquaredDifferenceOptions();
}

template<> inline const tflite::MirrorPadOptions *Operator::builtin_options_as<tflite::MirrorPadOptions>() const {
  return builtin_options_as_MirrorPadOptions();
}

template<> inline const tflite::AbsOptions *Operator::builtin_options_as<tflite::AbsOptions>() const {
  return builtin_options_as_AbsOptions();
}

template<> inline const tflite::SplitVOptions *Operator::builtin_options_as<tflite::SplitVOptions>() const {
  return builtin_options_as_SplitVOptions();
}

template<> inline const tflite::UniqueOptions *Operator::builtin_options_as<tflite::UniqueOptions>() const {
  return builtin_options_as_UniqueOptions();
}

template<> inline const tflite::ReverseV2Options *Operator::builtin_options_as<tflite::ReverseV2Options>() const {
  return builtin_options_as_ReverseV2Options();
}

template<> inline const tflite::AddNOptions *Operator::builtin_options_as<tflite::AddNOptions>() const {
  return builtin_options_as_AddNOptions();
}

template<> inline const tflite::GatherNdOptions *Operator::builtin_options_as<tflite::GatherNdOptions>() const {
  return builtin_options_as_GatherNdOptions();
}

template<> inline const tflite::CosOptions *Operator::builtin_options_as<tflite::CosOptions>() const {
  return builtin_options_as_CosOptions();
}

template<> inline const tflite::WhereOptions *Operator::builtin_options_as<tflite::WhereOptions>() const {
  return builtin_options_as_WhereOptions();
}

template<> inline const tflite::RankOptions *Operator::builtin_options_as<tflite::RankOptions>() const {
  return builtin_options_as_RankOptions();
}

template<> inline const tflite::ReverseSequenceOptions *Operator::builtin_options_as<tflite::ReverseSequenceOptions>() const {
  return builtin_options_as_ReverseSequenceOptions();
}

template<> inline const tflite::MatrixDiagOptions *Operator::builtin_options_as<tflite::MatrixDiagOptions>() const {
  return builtin_options_as_MatrixDiagOptions();
}

template<> inline const tflite::QuantizeOptions *Operator::builtin_options_as<tflite::QuantizeOptions>() const {
  return builtin_options_as_QuantizeOptions();
}

template<> inline const tflite::MatrixSetDiagOptions *Operator::builtin_options_as<tflite::MatrixSetDiagOptions>() const {
  return builtin_options_as_MatrixSetDiagOptions();
}

template<> inline const tflite::HardSwishOptions *Operator::builtin_options_as<tflite::HardSwishOptions>() const {
  return builtin_options_as_HardSwishOptions();
}

template<> inline const tflite::IfOptions *Operator::builtin_options_as<tflite::IfOptions>() const {
  return builtin_options_as_IfOptions();
}

template<> inline const tflite::WhileOptions *Operator::builtin_options_as<tflite::WhileOptions>() const {
  return builtin_options_as_WhileOptions();
}

template<> inline const tflite::DepthToSpaceOptions *Operator::builtin_options_as<tflite::DepthToSpaceOptions>() const {
  return builtin_options_as_DepthToSpaceOptions();
}

template<> inline const tflite::NonMaxSuppressionV4Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV4Options>() const {
  return builtin_options_as_NonMaxSuppressionV4Options();
}

template<> inline const tflite::NonMaxSuppressionV5Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV5Options>() const {
  return builtin_options_as_NonMaxSuppressionV5Options();
}

template<> inline const tflite::ScatterNdOptions *Operator::builtin_options_as<tflite::ScatterNdOptions>() const {
  return builtin_options_as_ScatterNdOptions();
}

template<> inline const tflite::SelectV2Options *Operator::builtin_options_as<tflite::SelectV2Options>() const {
  return builtin_options_as_SelectV2Options();
}

template<> inline const tflite::DensifyOptions *Operator::builtin_options_as<tflite::DensifyOptions>() const {
  return builtin_options_as_DensifyOptions();
}

template<> inline const tflite::SegmentSumOptions *Operator::builtin_options_as<tflite::SegmentSumOptions>() const {
  return builtin_options_as_SegmentSumOptions();
}

template<> inline const tflite::BatchMatMulOptions *Operator::builtin_options_as<tflite::BatchMatMulOptions>() const {
  return builtin_options_as_BatchMatMulOptions();
}

template<> inline const tflite::CumsumOptions *Operator::builtin_options_as<tflite::CumsumOptions>() const {
  return builtin_options_as_CumsumOptions();
}

template<> inline const tflite::CallOnceOptions *Operator::builtin_options_as<tflite::CallOnceOptions>() const {
  return builtin_options_as_CallOnceOptions();
}

template<> inline const tflite::BroadcastToOptions *Operator::builtin_options_as<tflite::BroadcastToOptions>() const {
  return builtin_options_as_BroadcastToOptions();
}

template<> inline const tflite::Rfft2dOptions *Operator::builtin_options_as<tflite::Rfft2dOptions>() const {
  return builtin_options_as_Rfft2dOptions();
}

template<> inline const tflite::Conv3DOptions *Operator::builtin_options_as<tflite::Conv3DOptions>() const {
  return builtin_options_as_Conv3DOptions();
}

template<> inline const tflite::HashtableOptions *Operator::builtin_options_as<tflite::HashtableOptions>() const {
  return builtin_options_as_HashtableOptions();
}

template<> inline const tflite::HashtableFindOptions *Operator::builtin_options_as<tflite::HashtableFindOptions>() const {
  return builtin_options_as_HashtableFindOptions();
}

template<> inline const tflite::HashtableImportOptions *Operator::builtin_options_as<tflite::HashtableImportOptions>() const {
  return builtin_options_as_HashtableImportOptions();
}

template<> inline const tflite::HashtableSizeOptions *Operator::builtin_options_as<tflite::HashtableSizeOptions>() const {
  return builtin_options_as_HashtableSizeOptions();
}

template<> inline const tflite::VarHandleOptions *Operator::builtin_options_as<tflite::VarHandleOptions>() const {
  return builtin_options_as_VarHandleOptions();
}

template<> inline const tflite::ReadVariableOptions *Operator::builtin_options_as<tflite::ReadVariableOptions>() const {
  return builtin_options_as_ReadVariableOptions();
}

template<> inline const tflite::AssignVariableOptions *Operator::builtin_options_as<tflite::AssignVariableOptions>() const {
  return builtin_options_as_AssignVariableOptions();
}

template<> inline const tflite::RandomOptions *Operator::builtin_options_as<tflite::RandomOptions>() const {
  return builtin_options_as_RandomOptions();
}

template<> inline const tflite::BucketizeOptions *Operator::builtin_options_as<tflite::BucketizeOptions>() const {
  return builtin_options_as_BucketizeOptions();
}

template<> inline const tflite::GeluOptions *Operator::builtin_options_as<tflite::GeluOptions>() const {
  return builtin_options_as_GeluOptions();
}

template<> inline const tflite::DynamicUpdateSliceOptions *Operator::builtin_options_as<tflite::DynamicUpdateSliceOptions>() const {
  return builtin_options_as_DynamicUpdateSliceOptions();
}

template<> inline const tflite::UnsortedSegmentProdOptions *Operator::builtin_options_as<tflite::UnsortedSegmentProdOptions>() const {
  return builtin_options_as_UnsortedSegmentProdOptions();
}

template<> inline const tflite::UnsortedSegmentMaxOptions *Operator::builtin_options_as<tflite::UnsortedSegmentMaxOptions>() const {
  return builtin_options_as_UnsortedSegmentMaxOptions();
}

template<> inline const tflite::UnsortedSegmentMinOptions *Operator::builtin_options_as<tflite::UnsortedSegmentMinOptions>() const {
  return builtin_options_as_UnsortedSegmentMinOptions();
}

template<> inline const tflite::UnsortedSegmentSumOptions *Operator::builtin_options_as<tflite::UnsortedSegmentSumOptions>() const {
  return builtin_options_as_UnsortedSegmentSumOptions();
}

template<> inline const tflite::ATan2Options *Operator::builtin_options_as<tflite::ATan2Options>() const {
  return builtin_options_as_ATan2Options();
}

template<> inline const tflite::SignOptions *Operator::builtin_options_as<tflite::SignOptions>() const {
  return builtin_options_as_SignOptions();
}

template<> inline const tflite::BitcastOptions *Operator::builtin_options_as<tflite::BitcastOptions>() const {
  return builtin_options_as_BitcastOptions();
}

template<> inline const tflite::BitwiseXorOptions *Operator::builtin_options_as<tflite::BitwiseXorOptions>() const {
  return builtin_options_as_BitwiseXorOptions();
}

template<> inline const tflite::RightShiftOptions *Operator::builtin_options_as<tflite::RightShiftOptions>() const {
  return builtin_options_as_RightShiftOptions();
}

template<> inline const tflite::StablehloConcatenateOptions *Operator::builtin_options_2_as<tflite::StablehloConcatenateOptions>() const {
  return builtin_options_2_as_StablehloConcatenateOptions();
}

template<> inline const tflite::StablehloBroadcastInDimOptions *Operator::builtin_options_2_as<tflite::StablehloBroadcastInDimOptions>() const {
  return builtin_options_2_as_StablehloBroadcastInDimOptions();
}

template<> inline const tflite::StablehloSliceOptions *Operator::builtin_options_2_as<tflite::StablehloSliceOptions>() const {
  return builtin_options_2_as_StablehloSliceOptions();
}

template<> inline const tflite::StablehloConvolutionOptions *Operator::builtin_options_2_as<tflite::StablehloConvolutionOptions>() const {
  return builtin_options_2_as_StablehloConvolutionOptions();
}

template<> inline const tflite::StablehloCustomCallOptions *Operator::builtin_options_2_as<tflite::StablehloCustomCallOptions>() const {
  return builtin_options_2_as_StablehloCustomCallOptions();
}

template<> inline const tflite::StablehloReduceOptions *Operator::builtin_options_2_as<tflite::StablehloReduceOptions>() const {
  return builtin_options_2_as_StablehloReduceOptions();
}

template<> inline const tflite::StablehloScatterOptions *Operator::builtin_options_2_as<tflite::StablehloScatterOptions>() const {
  return builtin_options_2_as_StablehloScatterOptions();
}

template<> inline const tflite::StablehloCompareOptions *Operator::builtin_options_2_as<tflite::StablehloCompareOptions>() const {
  return builtin_options_2_as_StablehloCompareOptions();
}

template<> inline const tflite::StablehloDynamicSliceOptions *Operator::builtin_options_2_as<tflite::StablehloDynamicSliceOptions>() const {
  return builtin_options_2_as_StablehloDynamicSliceOptions();
}

template<> inline const tflite::StablehloPadOptions *Operator::builtin_options_2_as<tflite::StablehloPadOptions>() const {
  return builtin_options_2_as_StablehloPadOptions();
}

template<> inline const tflite::StablehloIotaOptions *Operator::builtin_options_2_as<tflite::StablehloIotaOptions>() const {
  return builtin_options_2_as_StablehloIotaOptions();
}

template<> inline const tflite::StablehloDotGeneralOptions *Operator::builtin_options_2_as<tflite::StablehloDotGeneralOptions>() const {
  return builtin_options_2_as_StablehloDotGeneralOptions();
}

template<> inline const tflite::StablehloReduceWindowOptions *Operator::builtin_options_2_as<tflite::StablehloReduceWindowOptions>() const {
  return builtin_options_2_as_StablehloReduceWindowOptions();
}

template<> inline const tflite::StablehloSortOptions *Operator::builtin_options_2_as<tflite::StablehloSortOptions>() const {
  return builtin_options_2_as_StablehloSortOptions();
}

template<> inline const tflite::StablehloWhileOptions *Operator::builtin_options_2_as<tflite::StablehloWhileOptions>() const {
  return builtin_options_2_as_StablehloWhileOptions();
}

template<> inline const tflite::StablehloGatherOptions *Operator::builtin_options_2_as<tflite::StablehloGatherOptions>() const {
  return builtin_options_2_as_StablehloGatherOptions();
}

template<> inline const tflite::StablehloTransposeOptions *Operator::builtin_options_2_as<tflite::StablehloTransposeOptions>() const {
  return builtin_options_2_as_StablehloTransposeOptions();
}

template<> inline const tflite::DilateOptions *Operator::builtin_options_2_as<tflite::DilateOptions>() const {
  return builtin_options_2_as_DilateOptions();
}

template<> inline const tflite::StablehloRngBitGeneratorOptions *Operator::builtin_options_2_as<tflite::StablehloRngBitGeneratorOptions>() const {
  return builtin_options_2_as_StablehloRngBitGeneratorOptions();
}

template<> inline const tflite::ReduceWindowOptions *Operator::builtin_options_2_as<tflite::ReduceWindowOptions>() const {
  return builtin_options_2_as_ReduceWindowOptions();
}

template<> inline const tflite::StableHLOCompositeOptions *Operator::builtin_options_2_as<tflite::StableHLOCompositeOptions>() const {
  return builtin_options_2_as_StableHLOCompositeOptions();
}

template<> inline const tflite::StablehloShiftLeftOptions *Operator::builtin_options_2_as<tflite::StablehloShiftLeftOptions>() const {
  return builtin_options_2_as_StablehloShiftLeftOptions();
}

struct OperatorBuilder {
  typedef Operator Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_opcode_index(uint32_t opcode_index) {
    fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
    fbb_.AddOffset(Operator::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs) {
    fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
  }
  void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {
    fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0);
  }
  void add_builtin_options(::flatbuffers::Offset<void> builtin_options) {
    fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
  }
  void add_custom_options(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_options) {
    fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
  }
  void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) {
    fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
  }
  void add_mutating_variable_inputs(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
    fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
  }
  void add_intermediates(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> intermediates) {
    fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
  }
  void add_large_custom_options_offset(uint64_t large_custom_options_offset) {
    fbb_.AddElement<uint64_t>(Operator::VT_LARGE_CUSTOM_OPTIONS_OFFSET, large_custom_options_offset, 0);
  }
  void add_large_custom_options_size(uint64_t large_custom_options_size) {
    fbb_.AddElement<uint64_t>(Operator::VT_LARGE_CUSTOM_OPTIONS_SIZE, large_custom_options_size, 0);
  }
  void add_builtin_options_2_type(tflite::BuiltinOptions2 builtin_options_2_type) {
    fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_2_TYPE, static_cast<uint8_t>(builtin_options_2_type), 0);
  }
  void add_builtin_options_2(::flatbuffers::Offset<void> builtin_options_2) {
    fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS_2, builtin_options_2);
  }
  void add_debug_metadata_index(int32_t debug_metadata_index) {
    fbb_.AddElement<int32_t>(Operator::VT_DEBUG_METADATA_INDEX, debug_metadata_index, -1);
  }
  explicit OperatorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Operator> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Operator>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Operator> CreateOperator(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t opcode_index = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs = 0,
    tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions::NONE,
    ::flatbuffers::Offset<void> builtin_options = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> custom_options = 0,
    tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat::FLEXBUFFERS,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> intermediates = 0,
    uint64_t large_custom_options_offset = 0,
    uint64_t large_custom_options_size = 0,
    tflite::BuiltinOptions2 builtin_options_2_type = tflite::BuiltinOptions2::NONE,
    ::flatbuffers::Offset<void> builtin_options_2 = 0,
    int32_t debug_metadata_index = -1) {
  OperatorBuilder builder_(_fbb);
  builder_.add_large_custom_options_size(large_custom_options_size);
  builder_.add_large_custom_options_offset(large_custom_options_offset);
  builder_.add_debug_metadata_index(debug_metadata_index);
  builder_.add_builtin_options_2(builtin_options_2);
  builder_.add_intermediates(intermediates);
  builder_.add_mutating_variable_inputs(mutating_variable_inputs);
  builder_.add_custom_options(custom_options);
  builder_.add_builtin_options(builtin_options);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  builder_.add_opcode_index(opcode_index);
  builder_.add_builtin_options_2_type(builtin_options_2_type);
  builder_.add_custom_options_format(custom_options_format);
  builder_.add_builtin_options_type(builtin_options_type);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Operator> CreateOperatorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t opcode_index = 0,
    const std::vector<int32_t> *inputs = nullptr,
    const std::vector<int32_t> *outputs = nullptr,
    tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions::NONE,
    ::flatbuffers::Offset<void> builtin_options = 0,
    const std::vector<uint8_t> *custom_options = nullptr,
    tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat::FLEXBUFFERS,
    const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
    const std::vector<int32_t> *intermediates = nullptr,
    uint64_t large_custom_options_offset = 0,
    uint64_t large_custom_options_size = 0,
    tflite::BuiltinOptions2 builtin_options_2_type = tflite::BuiltinOptions2::NONE,
    ::flatbuffers::Offset<void> builtin_options_2 = 0,
    int32_t debug_metadata_index = -1) {
  auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
  auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
  auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
  auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
  return tflite::CreateOperator(
      _fbb,
      opcode_index,
      inputs__,
      outputs__,
      builtin_options_type,
      builtin_options,
      custom_options__,
      custom_options_format,
      mutating_variable_inputs__,
      intermediates__,
      large_custom_options_offset,
      large_custom_options_size,
      builtin_options_2_type,
      builtin_options_2,
      debug_metadata_index);
}

struct SubGraph FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SubGraphBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SubGraphTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TENSORS = 4,
    VT_INPUTS = 6,
    VT_OUTPUTS = 8,
    VT_OPERATORS = 10,
    VT_NAME = 12,
    VT_DEBUG_METADATA_INDEX = 14
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *tensors() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *mutable_tensors() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
  }
  const ::flatbuffers::Vector<int32_t> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_inputs() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<int32_t> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
  }
  ::flatbuffers::Vector<int32_t> *mutable_outputs() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *operators() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *mutable_operators() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  int32_t debug_metadata_index() const {
    return GetField<int32_t>(VT_DEBUG_METADATA_INDEX, -1);
  }
  bool mutate_debug_metadata_index(int32_t _debug_metadata_index = -1) {
    return SetField<int32_t>(VT_DEBUG_METADATA_INDEX, _debug_metadata_index, -1);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_TENSORS) &&
           verifier.VerifyVector(tensors()) &&
           verifier.VerifyVectorOfTables(tensors()) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           VerifyOffset(verifier, VT_OPERATORS) &&
           verifier.VerifyVector(operators()) &&
           verifier.VerifyVectorOfTables(operators()) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<int32_t>(verifier, VT_DEBUG_METADATA_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct SubGraphBuilder {
  typedef SubGraph Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_tensors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>>> tensors) {
    fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
    fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs) {
    fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
  }
  void add_operators(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>>> operators) {
    fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(SubGraph::VT_NAME, name);
  }
  void add_debug_metadata_index(int32_t debug_metadata_index) {
    fbb_.AddElement<int32_t>(SubGraph::VT_DEBUG_METADATA_INDEX, debug_metadata_index, -1);
  }
  explicit SubGraphBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SubGraph> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SubGraph>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SubGraph> CreateSubGraph(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Tensor>>> tensors = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Operator>>> operators = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    int32_t debug_metadata_index = -1) {
  SubGraphBuilder builder_(_fbb);
  builder_.add_debug_metadata_index(debug_metadata_index);
  builder_.add_name(name);
  builder_.add_operators(operators);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  builder_.add_tensors(tensors);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tflite::Tensor>> *tensors = nullptr,
    const std::vector<int32_t> *inputs = nullptr,
    const std::vector<int32_t> *outputs = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::Operator>> *operators = nullptr,
    const char *name = nullptr,
    int32_t debug_metadata_index = -1) {
  auto tensors__ = tensors ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Tensor>>(*tensors) : 0;
  auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
  auto operators__ = operators ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Operator>>(*operators) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return tflite::CreateSubGraph(
      _fbb,
      tensors__,
      inputs__,
      outputs__,
      operators__,
      name__,
      debug_metadata_index);
}

struct Buffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BufferBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BufferTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4,
    VT_OFFSET = 6,
    VT_SIZE = 8
  };
  const ::flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  ::flatbuffers::Vector<uint8_t> *mutable_data() {
    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  uint64_t offset() const {
    return GetField<uint64_t>(VT_OFFSET, 0);
  }
  bool mutate_offset(uint64_t _offset = 0) {
    return SetField<uint64_t>(VT_OFFSET, _offset, 0);
  }
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  bool mutate_size(uint64_t _size = 0) {
    return SetField<uint64_t>(VT_SIZE, _size, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           verifier.EndTable();
  }
};

struct BufferBuilder {
  typedef Buffer Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(Buffer::VT_DATA, data);
  }
  void add_offset(uint64_t offset) {
    fbb_.AddElement<uint64_t>(Buffer::VT_OFFSET, offset, 0);
  }
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(Buffer::VT_SIZE, size, 0);
  }
  explicit BufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Buffer> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Buffer>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Buffer> CreateBuffer(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
    uint64_t offset = 0,
    uint64_t size = 0) {
  BufferBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_offset(offset);
  builder_.add_data(data);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Buffer> CreateBufferDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr,
    uint64_t offset = 0,
    uint64_t size = 0) {
  if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16); }
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return tflite::CreateBuffer(
      _fbb,
      data__,
      offset,
      size);
}

struct Metadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MetadataBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MetadataTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_BUFFER = 6
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  uint32_t buffer() const {
    return GetField<uint32_t>(VT_BUFFER, 0);
  }
  bool mutate_buffer(uint32_t _buffer = 0) {
    return SetField<uint32_t>(VT_BUFFER, _buffer, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint32_t>(verifier, VT_BUFFER, 4) &&
           verifier.EndTable();
  }
};

struct MetadataBuilder {
  typedef Metadata Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Metadata::VT_NAME, name);
  }
  void add_buffer(uint32_t buffer) {
    fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0);
  }
  explicit MetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Metadata> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Metadata>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Metadata> CreateMetadata(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    uint32_t buffer = 0) {
  MetadataBuilder builder_(_fbb);
  builder_.add_buffer(buffer);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Metadata> CreateMetadataDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    uint32_t buffer = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return tflite::CreateMetadata(
      _fbb,
      name__,
      buffer);
}

struct TensorMap FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorMapBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return TensorMapTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_TENSOR_INDEX = 6
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  ::flatbuffers::String *mutable_name() {
    return GetPointer<::flatbuffers::String *>(VT_NAME);
  }
  uint32_t tensor_index() const {
    return GetField<uint32_t>(VT_TENSOR_INDEX, 0);
  }
  bool mutate_tensor_index(uint32_t _tensor_index = 0) {
    return SetField<uint32_t>(VT_TENSOR_INDEX, _tensor_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct TensorMapBuilder {
  typedef TensorMap Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(TensorMap::VT_NAME, name);
  }
  void add_tensor_index(uint32_t tensor_index) {
    fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
  }
  explicit TensorMapBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorMap> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorMap>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<TensorMap> CreateTensorMap(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    uint32_t tensor_index = 0) {
  TensorMapBuilder builder_(_fbb);
  builder_.add_tensor_index(tensor_index);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    uint32_t tensor_index = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return tflite::CreateTensorMap(
      _fbb,
      name__,
      tensor_index);
}

struct SignatureDef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SignatureDefBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return SignatureDefTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUTS = 4,
    VT_OUTPUTS = 6,
    VT_SIGNATURE_KEY = 8,
    VT_SUBGRAPH_INDEX = 12
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *mutable_inputs() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *mutable_outputs() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
  }
  const ::flatbuffers::String *signature_key() const {
    return GetPointer<const ::flatbuffers::String *>(VT_SIGNATURE_KEY);
  }
  ::flatbuffers::String *mutable_signature_key() {
    return GetPointer<::flatbuffers::String *>(VT_SIGNATURE_KEY);
  }
  uint32_t subgraph_index() const {
    return GetField<uint32_t>(VT_SUBGRAPH_INDEX, 0);
  }
  bool mutate_subgraph_index(uint32_t _subgraph_index = 0) {
    return SetField<uint32_t>(VT_SUBGRAPH_INDEX, _subgraph_index, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           verifier.VerifyVectorOfTables(outputs()) &&
           VerifyOffset(verifier, VT_SIGNATURE_KEY) &&
           verifier.VerifyString(signature_key()) &&
           VerifyField<uint32_t>(verifier, VT_SUBGRAPH_INDEX, 4) &&
           verifier.EndTable();
  }
};

struct SignatureDefBuilder {
  typedef SignatureDef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> inputs) {
    fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> outputs) {
    fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
  }
  void add_signature_key(::flatbuffers::Offset<::flatbuffers::String> signature_key) {
    fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key);
  }
  void add_subgraph_index(uint32_t subgraph_index) {
    fbb_.AddElement<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0);
  }
  explicit SignatureDefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SignatureDef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SignatureDef>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SignatureDef> CreateSignatureDef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::TensorMap>>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::String> signature_key = 0,
    uint32_t subgraph_index = 0) {
  SignatureDefBuilder builder_(_fbb);
  builder_.add_subgraph_index(subgraph_index);
  builder_.add_signature_key(signature_key);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tflite::TensorMap>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::TensorMap>> *outputs = nullptr,
    const char *signature_key = nullptr,
    uint32_t subgraph_index = 0) {
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::TensorMap>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::TensorMap>>(*outputs) : 0;
  auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0;
  return tflite::CreateSignatureDef(
      _fbb,
      inputs__,
      outputs__,
      signature_key__,
      subgraph_index);
}

struct Model FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ModelBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ModelTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VERSION = 4,
    VT_OPERATOR_CODES = 6,
    VT_SUBGRAPHS = 8,
    VT_DESCRIPTION = 10,
    VT_BUFFERS = 12,
    VT_METADATA_BUFFER = 14,
    VT_METADATA = 16,
    VT_SIGNATURE_DEFS = 18
  };
  uint32_t version() const {
    return GetField<uint32_t>(VT_VERSION, 0);
  }
  bool mutate_version(uint32_t _version = 0) {
    return SetField<uint32_t>(VT_VERSION, _version, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *operator_codes() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *mutable_operator_codes() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *subgraphs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *mutable_subgraphs() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
  }
  const ::flatbuffers::String *description() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
  }
  ::flatbuffers::String *mutable_description() {
    return GetPointer<::flatbuffers::String *>(VT_DESCRIPTION);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *buffers() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *mutable_buffers() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
  }
  const ::flatbuffers::Vector<int32_t> *metadata_buffer() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
  }
  ::flatbuffers::Vector<int32_t> *mutable_metadata_buffer() {
    return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *metadata() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *mutable_metadata() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *signature_defs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
  }
  ::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *mutable_signature_defs() {
    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
           VerifyOffset(verifier, VT_OPERATOR_CODES) &&
           verifier.VerifyVector(operator_codes()) &&
           verifier.VerifyVectorOfTables(operator_codes()) &&
           VerifyOffset(verifier, VT_SUBGRAPHS) &&
           verifier.VerifyVector(subgraphs()) &&
           verifier.VerifyVectorOfTables(subgraphs()) &&
           VerifyOffset(verifier, VT_DESCRIPTION) &&
           verifier.VerifyString(description()) &&
           VerifyOffset(verifier, VT_BUFFERS) &&
           verifier.VerifyVector(buffers()) &&
           verifier.VerifyVectorOfTables(buffers()) &&
           VerifyOffset(verifier, VT_METADATA_BUFFER) &&
           verifier.VerifyVector(metadata_buffer()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfTables(metadata()) &&
           VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
           verifier.VerifyVector(signature_defs()) &&
           verifier.VerifyVectorOfTables(signature_defs()) &&
           verifier.EndTable();
  }
};

struct ModelBuilder {
  typedef Model Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_version(uint32_t version) {
    fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0);
  }
  void add_operator_codes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
    fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
  }
  void add_subgraphs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
    fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
  }
  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
    fbb_.AddOffset(Model::VT_DESCRIPTION, description);
  }
  void add_buffers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>>> buffers) {
    fbb_.AddOffset(Model::VT_BUFFERS, buffers);
  }
  void add_metadata_buffer(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> metadata_buffer) {
    fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
  }
  void add_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>>> metadata) {
    fbb_.AddOffset(Model::VT_METADATA, metadata);
  }
  void add_signature_defs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
    fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
  }
  explicit ModelBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Model> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Model>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Model> CreateModel(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t version = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SubGraph>>> subgraphs = 0,
    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Buffer>>> buffers = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> metadata_buffer = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::Metadata>>> metadata = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = 0) {
  ModelBuilder builder_(_fbb);
  builder_.add_signature_defs(signature_defs);
  builder_.add_metadata(metadata);
  builder_.add_metadata_buffer(metadata_buffer);
  builder_.add_buffers(buffers);
  builder_.add_description(description);
  builder_.add_subgraphs(subgraphs);
  builder_.add_operator_codes(operator_codes);
  builder_.add_version(version);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Model> CreateModelDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t version = 0,
    const std::vector<::flatbuffers::Offset<tflite::OperatorCode>> *operator_codes = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::SubGraph>> *subgraphs = nullptr,
    const char *description = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::Buffer>> *buffers = nullptr,
    const std::vector<int32_t> *metadata_buffer = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::Metadata>> *metadata = nullptr,
    const std::vector<::flatbuffers::Offset<tflite::SignatureDef>> *signature_defs = nullptr) {
  auto operator_codes__ = operator_codes ? _fbb.CreateVector<::flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : 0;
  auto subgraphs__ = subgraphs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : 0;
  auto description__ = description ? _fbb.CreateString(description) : 0;
  auto buffers__ = buffers ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Buffer>>(*buffers) : 0;
  auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<::flatbuffers::Offset<tflite::Metadata>>(*metadata) : 0;
  auto signature_defs__ = signature_defs ? _fbb.CreateVector<::flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : 0;
  return tflite::CreateModel(
      _fbb,
      version,
      operator_codes__,
      subgraphs__,
      description__,
      buffers__,
      metadata_buffer__,
      metadata__,
      signature_defs__);
}

inline bool VerifyQuantizationDetails(::flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
  switch (type) {
    case QuantizationDetails::NONE: {
      return true;
    }
    case QuantizationDetails::CustomQuantization: {
      auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyQuantizationDetailsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationDetails> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyQuantizationDetails(
        verifier,  values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
      return false;
    }
  }
  return true;
}

inline bool VerifySparseIndexVector(::flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) {
  switch (type) {
    case SparseIndexVector::NONE: {
      return true;
    }
    case SparseIndexVector::Int32Vector: {
      auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case SparseIndexVector::Uint16Vector: {
      auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case SparseIndexVector::Uint8Vector: {
      auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifySparseIndexVectorVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<SparseIndexVector> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifySparseIndexVector(
        verifier,  values->Get(i), types->GetEnum<SparseIndexVector>(i))) {
      return false;
    }
  }
  return true;
}

inline bool VerifyBuiltinOptions(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
  switch (type) {
    case BuiltinOptions::NONE: {
      return true;
    }
    case BuiltinOptions::Conv2DOptions: {
      auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DepthwiseConv2DOptions: {
      auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ConcatEmbeddingsOptions: {
      auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LSHProjectionOptions: {
      auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::Pool2DOptions: {
      auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SVDFOptions: {
      auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::RNNOptions: {
      auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::FullyConnectedOptions: {
      auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SoftmaxOptions: {
      auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ConcatenationOptions: {
      auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::AddOptions: {
      auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::L2NormOptions: {
      auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LocalResponseNormalizationOptions: {
      auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LSTMOptions: {
      auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ResizeBilinearOptions: {
      auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::CallOptions: {
      auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ReshapeOptions: {
      auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SkipGramOptions: {
      auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SpaceToDepthOptions: {
      auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::EmbeddingLookupSparseOptions: {
      auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::MulOptions: {
      auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::PadOptions: {
      auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::GatherOptions: {
      auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BatchToSpaceNDOptions: {
      auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SpaceToBatchNDOptions: {
      auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::TransposeOptions: {
      auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ReducerOptions: {
      auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SubOptions: {
      auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DivOptions: {
      auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SqueezeOptions: {
      auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SequenceRNNOptions: {
      auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::StridedSliceOptions: {
      auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ExpOptions: {
      auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::TopKV2Options: {
      auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SplitOptions: {
      auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LogSoftmaxOptions: {
      auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::CastOptions: {
      auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DequantizeOptions: {
      auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::MaximumMinimumOptions: {
      auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ArgMaxOptions: {
      auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LessOptions: {
      auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::NegOptions: {
      auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::PadV2Options: {
      auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::GreaterOptions: {
      auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::GreaterEqualOptions: {
      auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LessEqualOptions: {
      auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SelectOptions: {
      auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SliceOptions: {
      auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::TransposeConvOptions: {
      auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SparseToDenseOptions: {
      auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::TileOptions: {
      auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ExpandDimsOptions: {
      auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::EqualOptions: {
      auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::NotEqualOptions: {
      auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ShapeOptions: {
      auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::PowOptions: {
      auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ArgMinOptions: {
      auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::FakeQuantOptions: {
      auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::PackOptions: {
      auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LogicalOrOptions: {
      auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::OneHotOptions: {
      auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LogicalAndOptions: {
      auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LogicalNotOptions: {
      auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnpackOptions: {
      auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::FloorDivOptions: {
      auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SquareOptions: {
      auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ZerosLikeOptions: {
      auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::FillOptions: {
      auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BidirectionalSequenceLSTMOptions: {
      auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BidirectionalSequenceRNNOptions: {
      auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnidirectionalSequenceLSTMOptions: {
      auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::FloorModOptions: {
      auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::RangeOptions: {
      auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ResizeNearestNeighborOptions: {
      auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::LeakyReluOptions: {
      auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SquaredDifferenceOptions: {
      auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::MirrorPadOptions: {
      auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::AbsOptions: {
      auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SplitVOptions: {
      auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UniqueOptions: {
      auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ReverseV2Options: {
      auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::AddNOptions: {
      auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::GatherNdOptions: {
      auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::CosOptions: {
      auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::WhereOptions: {
      auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::RankOptions: {
      auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ReverseSequenceOptions: {
      auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::MatrixDiagOptions: {
      auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::QuantizeOptions: {
      auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::MatrixSetDiagOptions: {
      auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::HardSwishOptions: {
      auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::IfOptions: {
      auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::WhileOptions: {
      auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DepthToSpaceOptions: {
      auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::NonMaxSuppressionV4Options: {
      auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::NonMaxSuppressionV5Options: {
      auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ScatterNdOptions: {
      auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SelectV2Options: {
      auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DensifyOptions: {
      auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SegmentSumOptions: {
      auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BatchMatMulOptions: {
      auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::CumsumOptions: {
      auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::CallOnceOptions: {
      auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BroadcastToOptions: {
      auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::Rfft2dOptions: {
      auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::Conv3DOptions: {
      auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::HashtableOptions: {
      auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::HashtableFindOptions: {
      auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::HashtableImportOptions: {
      auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::HashtableSizeOptions: {
      auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::VarHandleOptions: {
      auto ptr = reinterpret_cast<const tflite::VarHandleOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ReadVariableOptions: {
      auto ptr = reinterpret_cast<const tflite::ReadVariableOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::AssignVariableOptions: {
      auto ptr = reinterpret_cast<const tflite::AssignVariableOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::RandomOptions: {
      auto ptr = reinterpret_cast<const tflite::RandomOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BucketizeOptions: {
      auto ptr = reinterpret_cast<const tflite::BucketizeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::GeluOptions: {
      auto ptr = reinterpret_cast<const tflite::GeluOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::DynamicUpdateSliceOptions: {
      auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnsortedSegmentProdOptions: {
      auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnsortedSegmentMaxOptions: {
      auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnsortedSegmentMinOptions: {
      auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::UnsortedSegmentSumOptions: {
      auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::ATan2Options: {
      auto ptr = reinterpret_cast<const tflite::ATan2Options *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::SignOptions: {
      auto ptr = reinterpret_cast<const tflite::SignOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BitcastOptions: {
      auto ptr = reinterpret_cast<const tflite::BitcastOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::BitwiseXorOptions: {
      auto ptr = reinterpret_cast<const tflite::BitwiseXorOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions::RightShiftOptions: {
      auto ptr = reinterpret_cast<const tflite::RightShiftOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyBuiltinOptionsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<BuiltinOptions> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyBuiltinOptions(
        verifier,  values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
      return false;
    }
  }
  return true;
}

inline bool VerifyBuiltinOptions2(::flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions2 type) {
  switch (type) {
    case BuiltinOptions2::NONE: {
      return true;
    }
    case BuiltinOptions2::StablehloConcatenateOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloConcatenateOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloBroadcastInDimOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloBroadcastInDimOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloSliceOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloSliceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloConvolutionOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloConvolutionOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloCustomCallOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloCustomCallOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloReduceOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloReduceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloScatterOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloScatterOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloCompareOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloCompareOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloDynamicSliceOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloDynamicSliceOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloPadOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloPadOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloIotaOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloIotaOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloDotGeneralOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloDotGeneralOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloReduceWindowOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloReduceWindowOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloSortOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloSortOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloWhileOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloWhileOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloGatherOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloGatherOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloTransposeOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloTransposeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::DilateOptions: {
      auto ptr = reinterpret_cast<const tflite::DilateOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloRngBitGeneratorOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloRngBitGeneratorOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::ReduceWindowOptions: {
      auto ptr = reinterpret_cast<const tflite::ReduceWindowOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StableHLOCompositeOptions: {
      auto ptr = reinterpret_cast<const tflite::StableHLOCompositeOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case BuiltinOptions2::StablehloShiftLeftOptions: {
      auto ptr = reinterpret_cast<const tflite::StablehloShiftLeftOptions *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyBuiltinOptions2Vector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<BuiltinOptions2> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyBuiltinOptions2(
        verifier,  values->Get(i), types->GetEnum<BuiltinOptions2>(i))) {
      return false;
    }
  }
  return true;
}

inline const ::flatbuffers::TypeTable *TensorTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "FLOAT32",
    "FLOAT16",
    "INT32",
    "UINT8",
    "INT64",
    "STRING",
    "BOOL",
    "INT16",
    "COMPLEX64",
    "INT8",
    "FLOAT64",
    "COMPLEX128",
    "UINT64",
    "RESOURCE",
    "VARIANT",
    "UINT32",
    "UINT16",
    "INT4",
    "BFLOAT16"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 19, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *QuantizationDetailsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::CustomQuantizationTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "CustomQuantization"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DimensionTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::DimensionTypeTypeTable
  };
  static const char * const names[] = {
    "DENSE",
    "SPARSE_CSR"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SparseIndexVectorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::Int32VectorTypeTable,
    tflite::Uint16VectorTypeTable,
    tflite::Uint8VectorTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "Int32Vector",
    "Uint16Vector",
    "Uint8Vector"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BuiltinOperatorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::BuiltinOperatorTypeTable
  };
  static const char * const names[] = {
    "ADD",
    "AVERAGE_POOL_2D",
    "CONCATENATION",
    "CONV_2D",
    "DEPTHWISE_CONV_2D",
    "DEPTH_TO_SPACE",
    "DEQUANTIZE",
    "EMBEDDING_LOOKUP",
    "FLOOR",
    "FULLY_CONNECTED",
    "HASHTABLE_LOOKUP",
    "L2_NORMALIZATION",
    "L2_POOL_2D",
    "LOCAL_RESPONSE_NORMALIZATION",
    "LOGISTIC",
    "LSH_PROJECTION",
    "LSTM",
    "MAX_POOL_2D",
    "MUL",
    "RELU",
    "RELU_N1_TO_1",
    "RELU6",
    "RESHAPE",
    "RESIZE_BILINEAR",
    "RNN",
    "SOFTMAX",
    "SPACE_TO_DEPTH",
    "SVDF",
    "TANH",
    "CONCAT_EMBEDDINGS",
    "SKIP_GRAM",
    "CALL",
    "CUSTOM",
    "EMBEDDING_LOOKUP_SPARSE",
    "PAD",
    "UNIDIRECTIONAL_SEQUENCE_RNN",
    "GATHER",
    "BATCH_TO_SPACE_ND",
    "SPACE_TO_BATCH_ND",
    "TRANSPOSE",
    "MEAN",
    "SUB",
    "DIV",
    "SQUEEZE",
    "UNIDIRECTIONAL_SEQUENCE_LSTM",
    "STRIDED_SLICE",
    "BIDIRECTIONAL_SEQUENCE_RNN",
    "EXP",
    "TOPK_V2",
    "SPLIT",
    "LOG_SOFTMAX",
    "DELEGATE",
    "BIDIRECTIONAL_SEQUENCE_LSTM",
    "CAST",
    "PRELU",
    "MAXIMUM",
    "ARGMAX",
    "MINIMUM",
    "LESS",
    "NEG",
    "PADV2",
    "GREATER",
    "GREATER_EQUAL",
    "LESS_EQUAL",
    "SELECT",
    "SLICE",
    "SIN",
    "TRANSPOSE_CONV",
    "SPARSE_TO_DENSE",
    "TILE",
    "EXPAND_DIMS",
    "EQUAL",
    "NOT_EQUAL",
    "LOG",
    "SUM",
    "SQRT",
    "RSQRT",
    "SHAPE",
    "POW",
    "ARG_MIN",
    "FAKE_QUANT",
    "REDUCE_PROD",
    "REDUCE_MAX",
    "PACK",
    "LOGICAL_OR",
    "ONE_HOT",
    "LOGICAL_AND",
    "LOGICAL_NOT",
    "UNPACK",
    "REDUCE_MIN",
    "FLOOR_DIV",
    "REDUCE_ANY",
    "SQUARE",
    "ZEROS_LIKE",
    "FILL",
    "FLOOR_MOD",
    "RANGE",
    "RESIZE_NEAREST_NEIGHBOR",
    "LEAKY_RELU",
    "SQUARED_DIFFERENCE",
    "MIRROR_PAD",
    "ABS",
    "SPLIT_V",
    "UNIQUE",
    "CEIL",
    "REVERSE_V2",
    "ADD_N",
    "GATHER_ND",
    "COS",
    "WHERE",
    "RANK",
    "ELU",
    "REVERSE_SEQUENCE",
    "MATRIX_DIAG",
    "QUANTIZE",
    "MATRIX_SET_DIAG",
    "ROUND",
    "HARD_SWISH",
    "IF",
    "WHILE",
    "NON_MAX_SUPPRESSION_V4",
    "NON_MAX_SUPPRESSION_V5",
    "SCATTER_ND",
    "SELECT_V2",
    "DENSIFY",
    "SEGMENT_SUM",
    "BATCH_MATMUL",
    "PLACEHOLDER_FOR_GREATER_OP_CODES",
    "CUMSUM",
    "CALL_ONCE",
    "BROADCAST_TO",
    "RFFT2D",
    "CONV_3D",
    "IMAG",
    "REAL",
    "COMPLEX_ABS",
    "HASHTABLE",
    "HASHTABLE_FIND",
    "HASHTABLE_IMPORT",
    "HASHTABLE_SIZE",
    "REDUCE_ALL",
    "CONV_3D_TRANSPOSE",
    "VAR_HANDLE",
    "READ_VARIABLE",
    "ASSIGN_VARIABLE",
    "BROADCAST_ARGS",
    "RANDOM_STANDARD_NORMAL",
    "BUCKETIZE",
    "RANDOM_UNIFORM",
    "MULTINOMIAL",
    "GELU",
    "DYNAMIC_UPDATE_SLICE",
    "RELU_0_TO_1",
    "UNSORTED_SEGMENT_PROD",
    "UNSORTED_SEGMENT_MAX",
    "UNSORTED_SEGMENT_SUM",
    "ATAN2",
    "UNSORTED_SEGMENT_MIN",
    "SIGN",
    "BITCAST",
    "BITWISE_XOR",
    "RIGHT_SHIFT",
    "STABLEHLO_LOGISTIC",
    "STABLEHLO_ADD",
    "STABLEHLO_DIVIDE",
    "STABLEHLO_MULTIPLY",
    "STABLEHLO_MAXIMUM",
    "STABLEHLO_RESHAPE",
    "STABLEHLO_CLAMP",
    "STABLEHLO_CONCATENATE",
    "STABLEHLO_BROADCAST_IN_DIM",
    "STABLEHLO_CONVOLUTION",
    "STABLEHLO_SLICE",
    "STABLEHLO_CUSTOM_CALL",
    "STABLEHLO_REDUCE",
    "STABLEHLO_ABS",
    "STABLEHLO_AND",
    "STABLEHLO_COSINE",
    "STABLEHLO_EXPONENTIAL",
    "STABLEHLO_FLOOR",
    "STABLEHLO_LOG",
    "STABLEHLO_MINIMUM",
    "STABLEHLO_NEGATE",
    "STABLEHLO_OR",
    "STABLEHLO_POWER",
    "STABLEHLO_REMAINDER",
    "STABLEHLO_RSQRT",
    "STABLEHLO_SELECT",
    "STABLEHLO_SUBTRACT",
    "STABLEHLO_TANH",
    "STABLEHLO_SCATTER",
    "STABLEHLO_COMPARE",
    "STABLEHLO_CONVERT",
    "STABLEHLO_DYNAMIC_SLICE",
    "STABLEHLO_DYNAMIC_UPDATE_SLICE",
    "STABLEHLO_PAD",
    "STABLEHLO_IOTA",
    "STABLEHLO_DOT_GENERAL",
    "STABLEHLO_REDUCE_WINDOW",
    "STABLEHLO_SORT",
    "STABLEHLO_WHILE",
    "STABLEHLO_GATHER",
    "STABLEHLO_TRANSPOSE",
    "DILATE",
    "STABLEHLO_RNG_BIT_GENERATOR",
    "REDUCE_WINDOW",
    "STABLEHLO_COMPOSITE",
    "STABLEHLO_SHIFT_LEFT",
    "STABLEHLO_CBRT"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 209, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BuiltinOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
    { ::flatbuffers::ET_SEQUENCE, 0, 3 },
    { ::flatbuffers::ET_SEQUENCE, 0, 4 },
    { ::flatbuffers::ET_SEQUENCE, 0, 5 },
    { ::flatbuffers::ET_SEQUENCE, 0, 6 },
    { ::flatbuffers::ET_SEQUENCE, 0, 7 },
    { ::flatbuffers::ET_SEQUENCE, 0, 8 },
    { ::flatbuffers::ET_SEQUENCE, 0, 9 },
    { ::flatbuffers::ET_SEQUENCE, 0, 10 },
    { ::flatbuffers::ET_SEQUENCE, 0, 11 },
    { ::flatbuffers::ET_SEQUENCE, 0, 12 },
    { ::flatbuffers::ET_SEQUENCE, 0, 13 },
    { ::flatbuffers::ET_SEQUENCE, 0, 14 },
    { ::flatbuffers::ET_SEQUENCE, 0, 15 },
    { ::flatbuffers::ET_SEQUENCE, 0, 16 },
    { ::flatbuffers::ET_SEQUENCE, 0, 17 },
    { ::flatbuffers::ET_SEQUENCE, 0, 18 },
    { ::flatbuffers::ET_SEQUENCE, 0, 19 },
    { ::flatbuffers::ET_SEQUENCE, 0, 20 },
    { ::flatbuffers::ET_SEQUENCE, 0, 21 },
    { ::flatbuffers::ET_SEQUENCE, 0, 22 },
    { ::flatbuffers::ET_SEQUENCE, 0, 23 },
    { ::flatbuffers::ET_SEQUENCE, 0, 24 },
    { ::flatbuffers::ET_SEQUENCE, 0, 25 },
    { ::flatbuffers::ET_SEQUENCE, 0, 26 },
    { ::flatbuffers::ET_SEQUENCE, 0, 27 },
    { ::flatbuffers::ET_SEQUENCE, 0, 28 },
    { ::flatbuffers::ET_SEQUENCE, 0, 29 },
    { ::flatbuffers::ET_SEQUENCE, 0, 30 },
    { ::flatbuffers::ET_SEQUENCE, 0, 31 },
    { ::flatbuffers::ET_SEQUENCE, 0, 32 },
    { ::flatbuffers::ET_SEQUENCE, 0, 33 },
    { ::flatbuffers::ET_SEQUENCE, 0, 34 },
    { ::flatbuffers::ET_SEQUENCE, 0, 35 },
    { ::flatbuffers::ET_SEQUENCE, 0, 36 },
    { ::flatbuffers::ET_SEQUENCE, 0, 37 },
    { ::flatbuffers::ET_SEQUENCE, 0, 38 },
    { ::flatbuffers::ET_SEQUENCE, 0, 39 },
    { ::flatbuffers::ET_SEQUENCE, 0, 40 },
    { ::flatbuffers::ET_SEQUENCE, 0, 41 },
    { ::flatbuffers::ET_SEQUENCE, 0, 42 },
    { ::flatbuffers::ET_SEQUENCE, 0, 43 },
    { ::flatbuffers::ET_SEQUENCE, 0, 44 },
    { ::flatbuffers::ET_SEQUENCE, 0, 45 },
    { ::flatbuffers::ET_SEQUENCE, 0, 46 },
    { ::flatbuffers::ET_SEQUENCE, 0, 47 },
    { ::flatbuffers::ET_SEQUENCE, 0, 48 },
    { ::flatbuffers::ET_SEQUENCE, 0, 49 },
    { ::flatbuffers::ET_SEQUENCE, 0, 50 },
    { ::flatbuffers::ET_SEQUENCE, 0, 51 },
    { ::flatbuffers::ET_SEQUENCE, 0, 52 },
    { ::flatbuffers::ET_SEQUENCE, 0, 53 },
    { ::flatbuffers::ET_SEQUENCE, 0, 54 },
    { ::flatbuffers::ET_SEQUENCE, 0, 55 },
    { ::flatbuffers::ET_SEQUENCE, 0, 56 },
    { ::flatbuffers::ET_SEQUENCE, 0, 57 },
    { ::flatbuffers::ET_SEQUENCE, 0, 58 },
    { ::flatbuffers::ET_SEQUENCE, 0, 59 },
    { ::flatbuffers::ET_SEQUENCE, 0, 60 },
    { ::flatbuffers::ET_SEQUENCE, 0, 61 },
    { ::flatbuffers::ET_SEQUENCE, 0, 62 },
    { ::flatbuffers::ET_SEQUENCE, 0, 63 },
    { ::flatbuffers::ET_SEQUENCE, 0, 64 },
    { ::flatbuffers::ET_SEQUENCE, 0, 65 },
    { ::flatbuffers::ET_SEQUENCE, 0, 66 },
    { ::flatbuffers::ET_SEQUENCE, 0, 67 },
    { ::flatbuffers::ET_SEQUENCE, 0, 68 },
    { ::flatbuffers::ET_SEQUENCE, 0, 69 },
    { ::flatbuffers::ET_SEQUENCE, 0, 70 },
    { ::flatbuffers::ET_SEQUENCE, 0, 71 },
    { ::flatbuffers::ET_SEQUENCE, 0, 72 },
    { ::flatbuffers::ET_SEQUENCE, 0, 73 },
    { ::flatbuffers::ET_SEQUENCE, 0, 74 },
    { ::flatbuffers::ET_SEQUENCE, 0, 75 },
    { ::flatbuffers::ET_SEQUENCE, 0, 76 },
    { ::flatbuffers::ET_SEQUENCE, 0, 77 },
    { ::flatbuffers::ET_SEQUENCE, 0, 78 },
    { ::flatbuffers::ET_SEQUENCE, 0, 79 },
    { ::flatbuffers::ET_SEQUENCE, 0, 80 },
    { ::flatbuffers::ET_SEQUENCE, 0, 81 },
    { ::flatbuffers::ET_SEQUENCE, 0, 82 },
    { ::flatbuffers::ET_SEQUENCE, 0, 83 },
    { ::flatbuffers::ET_SEQUENCE, 0, 84 },
    { ::flatbuffers::ET_SEQUENCE, 0, 85 },
    { ::flatbuffers::ET_SEQUENCE, 0, 86 },
    { ::flatbuffers::ET_SEQUENCE, 0, 87 },
    { ::flatbuffers::ET_SEQUENCE, 0, 88 },
    { ::flatbuffers::ET_SEQUENCE, 0, 89 },
    { ::flatbuffers::ET_SEQUENCE, 0, 90 },
    { ::flatbuffers::ET_SEQUENCE, 0, 91 },
    { ::flatbuffers::ET_SEQUENCE, 0, 92 },
    { ::flatbuffers::ET_SEQUENCE, 0, 93 },
    { ::flatbuffers::ET_SEQUENCE, 0, 94 },
    { ::flatbuffers::ET_SEQUENCE, 0, 95 },
    { ::flatbuffers::ET_SEQUENCE, 0, 96 },
    { ::flatbuffers::ET_SEQUENCE, 0, 97 },
    { ::flatbuffers::ET_SEQUENCE, 0, 98 },
    { ::flatbuffers::ET_SEQUENCE, 0, 99 },
    { ::flatbuffers::ET_SEQUENCE, 0, 100 },
    { ::flatbuffers::ET_SEQUENCE, 0, 101 },
    { ::flatbuffers::ET_SEQUENCE, 0, 102 },
    { ::flatbuffers::ET_SEQUENCE, 0, 103 },
    { ::flatbuffers::ET_SEQUENCE, 0, 104 },
    { ::flatbuffers::ET_SEQUENCE, 0, 105 },
    { ::flatbuffers::ET_SEQUENCE, 0, 106 },
    { ::flatbuffers::ET_SEQUENCE, 0, 107 },
    { ::flatbuffers::ET_SEQUENCE, 0, 108 },
    { ::flatbuffers::ET_SEQUENCE, 0, 109 },
    { ::flatbuffers::ET_SEQUENCE, 0, 110 },
    { ::flatbuffers::ET_SEQUENCE, 0, 111 },
    { ::flatbuffers::ET_SEQUENCE, 0, 112 },
    { ::flatbuffers::ET_SEQUENCE, 0, 113 },
    { ::flatbuffers::ET_SEQUENCE, 0, 114 },
    { ::flatbuffers::ET_SEQUENCE, 0, 115 },
    { ::flatbuffers::ET_SEQUENCE, 0, 116 },
    { ::flatbuffers::ET_SEQUENCE, 0, 117 },
    { ::flatbuffers::ET_SEQUENCE, 0, 118 },
    { ::flatbuffers::ET_SEQUENCE, 0, 119 },
    { ::flatbuffers::ET_SEQUENCE, 0, 120 },
    { ::flatbuffers::ET_SEQUENCE, 0, 121 },
    { ::flatbuffers::ET_SEQUENCE, 0, 122 },
    { ::flatbuffers::ET_SEQUENCE, 0, 123 },
    { ::flatbuffers::ET_SEQUENCE, 0, 124 },
    { ::flatbuffers::ET_SEQUENCE, 0, 125 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::Conv2DOptionsTypeTable,
    tflite::DepthwiseConv2DOptionsTypeTable,
    tflite::ConcatEmbeddingsOptionsTypeTable,
    tflite::LSHProjectionOptionsTypeTable,
    tflite::Pool2DOptionsTypeTable,
    tflite::SVDFOptionsTypeTable,
    tflite::RNNOptionsTypeTable,
    tflite::FullyConnectedOptionsTypeTable,
    tflite::SoftmaxOptionsTypeTable,
    tflite::ConcatenationOptionsTypeTable,
    tflite::AddOptionsTypeTable,
    tflite::L2NormOptionsTypeTable,
    tflite::LocalResponseNormalizationOptionsTypeTable,
    tflite::LSTMOptionsTypeTable,
    tflite::ResizeBilinearOptionsTypeTable,
    tflite::CallOptionsTypeTable,
    tflite::ReshapeOptionsTypeTable,
    tflite::SkipGramOptionsTypeTable,
    tflite::SpaceToDepthOptionsTypeTable,
    tflite::EmbeddingLookupSparseOptionsTypeTable,
    tflite::MulOptionsTypeTable,
    tflite::PadOptionsTypeTable,
    tflite::GatherOptionsTypeTable,
    tflite::BatchToSpaceNDOptionsTypeTable,
    tflite::SpaceToBatchNDOptionsTypeTable,
    tflite::TransposeOptionsTypeTable,
    tflite::ReducerOptionsTypeTable,
    tflite::SubOptionsTypeTable,
    tflite::DivOptionsTypeTable,
    tflite::SqueezeOptionsTypeTable,
    tflite::SequenceRNNOptionsTypeTable,
    tflite::StridedSliceOptionsTypeTable,
    tflite::ExpOptionsTypeTable,
    tflite::TopKV2OptionsTypeTable,
    tflite::SplitOptionsTypeTable,
    tflite::LogSoftmaxOptionsTypeTable,
    tflite::CastOptionsTypeTable,
    tflite::DequantizeOptionsTypeTable,
    tflite::MaximumMinimumOptionsTypeTable,
    tflite::ArgMaxOptionsTypeTable,
    tflite::LessOptionsTypeTable,
    tflite::NegOptionsTypeTable,
    tflite::PadV2OptionsTypeTable,
    tflite::GreaterOptionsTypeTable,
    tflite::GreaterEqualOptionsTypeTable,
    tflite::LessEqualOptionsTypeTable,
    tflite::SelectOptionsTypeTable,
    tflite::SliceOptionsTypeTable,
    tflite::TransposeConvOptionsTypeTable,
    tflite::SparseToDenseOptionsTypeTable,
    tflite::TileOptionsTypeTable,
    tflite::ExpandDimsOptionsTypeTable,
    tflite::EqualOptionsTypeTable,
    tflite::NotEqualOptionsTypeTable,
    tflite::ShapeOptionsTypeTable,
    tflite::PowOptionsTypeTable,
    tflite::ArgMinOptionsTypeTable,
    tflite::FakeQuantOptionsTypeTable,
    tflite::PackOptionsTypeTable,
    tflite::LogicalOrOptionsTypeTable,
    tflite::OneHotOptionsTypeTable,
    tflite::LogicalAndOptionsTypeTable,
    tflite::LogicalNotOptionsTypeTable,
    tflite::UnpackOptionsTypeTable,
    tflite::FloorDivOptionsTypeTable,
    tflite::SquareOptionsTypeTable,
    tflite::ZerosLikeOptionsTypeTable,
    tflite::FillOptionsTypeTable,
    tflite::BidirectionalSequenceLSTMOptionsTypeTable,
    tflite::BidirectionalSequenceRNNOptionsTypeTable,
    tflite::UnidirectionalSequenceLSTMOptionsTypeTable,
    tflite::FloorModOptionsTypeTable,
    tflite::RangeOptionsTypeTable,
    tflite::ResizeNearestNeighborOptionsTypeTable,
    tflite::LeakyReluOptionsTypeTable,
    tflite::SquaredDifferenceOptionsTypeTable,
    tflite::MirrorPadOptionsTypeTable,
    tflite::AbsOptionsTypeTable,
    tflite::SplitVOptionsTypeTable,
    tflite::UniqueOptionsTypeTable,
    tflite::ReverseV2OptionsTypeTable,
    tflite::AddNOptionsTypeTable,
    tflite::GatherNdOptionsTypeTable,
    tflite::CosOptionsTypeTable,
    tflite::WhereOptionsTypeTable,
    tflite::RankOptionsTypeTable,
    tflite::ReverseSequenceOptionsTypeTable,
    tflite::MatrixDiagOptionsTypeTable,
    tflite::QuantizeOptionsTypeTable,
    tflite::MatrixSetDiagOptionsTypeTable,
    tflite::HardSwishOptionsTypeTable,
    tflite::IfOptionsTypeTable,
    tflite::WhileOptionsTypeTable,
    tflite::DepthToSpaceOptionsTypeTable,
    tflite::NonMaxSuppressionV4OptionsTypeTable,
    tflite::NonMaxSuppressionV5OptionsTypeTable,
    tflite::ScatterNdOptionsTypeTable,
    tflite::SelectV2OptionsTypeTable,
    tflite::DensifyOptionsTypeTable,
    tflite::SegmentSumOptionsTypeTable,
    tflite::BatchMatMulOptionsTypeTable,
    tflite::CumsumOptionsTypeTable,
    tflite::CallOnceOptionsTypeTable,
    tflite::BroadcastToOptionsTypeTable,
    tflite::Rfft2dOptionsTypeTable,
    tflite::Conv3DOptionsTypeTable,
    tflite::HashtableOptionsTypeTable,
    tflite::HashtableFindOptionsTypeTable,
    tflite::HashtableImportOptionsTypeTable,
    tflite::HashtableSizeOptionsTypeTable,
    tflite::VarHandleOptionsTypeTable,
    tflite::ReadVariableOptionsTypeTable,
    tflite::AssignVariableOptionsTypeTable,
    tflite::RandomOptionsTypeTable,
    tflite::BucketizeOptionsTypeTable,
    tflite::GeluOptionsTypeTable,
    tflite::DynamicUpdateSliceOptionsTypeTable,
    tflite::UnsortedSegmentProdOptionsTypeTable,
    tflite::UnsortedSegmentMaxOptionsTypeTable,
    tflite::UnsortedSegmentMinOptionsTypeTable,
    tflite::UnsortedSegmentSumOptionsTypeTable,
    tflite::ATan2OptionsTypeTable,
    tflite::SignOptionsTypeTable,
    tflite::BitcastOptionsTypeTable,
    tflite::BitwiseXorOptionsTypeTable,
    tflite::RightShiftOptionsTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "Conv2DOptions",
    "DepthwiseConv2DOptions",
    "ConcatEmbeddingsOptions",
    "LSHProjectionOptions",
    "Pool2DOptions",
    "SVDFOptions",
    "RNNOptions",
    "FullyConnectedOptions",
    "SoftmaxOptions",
    "ConcatenationOptions",
    "AddOptions",
    "L2NormOptions",
    "LocalResponseNormalizationOptions",
    "LSTMOptions",
    "ResizeBilinearOptions",
    "CallOptions",
    "ReshapeOptions",
    "SkipGramOptions",
    "SpaceToDepthOptions",
    "EmbeddingLookupSparseOptions",
    "MulOptions",
    "PadOptions",
    "GatherOptions",
    "BatchToSpaceNDOptions",
    "SpaceToBatchNDOptions",
    "TransposeOptions",
    "ReducerOptions",
    "SubOptions",
    "DivOptions",
    "SqueezeOptions",
    "SequenceRNNOptions",
    "StridedSliceOptions",
    "ExpOptions",
    "TopKV2Options",
    "SplitOptions",
    "LogSoftmaxOptions",
    "CastOptions",
    "DequantizeOptions",
    "MaximumMinimumOptions",
    "ArgMaxOptions",
    "LessOptions",
    "NegOptions",
    "PadV2Options",
    "GreaterOptions",
    "GreaterEqualOptions",
    "LessEqualOptions",
    "SelectOptions",
    "SliceOptions",
    "TransposeConvOptions",
    "SparseToDenseOptions",
    "TileOptions",
    "ExpandDimsOptions",
    "EqualOptions",
    "NotEqualOptions",
    "ShapeOptions",
    "PowOptions",
    "ArgMinOptions",
    "FakeQuantOptions",
    "PackOptions",
    "LogicalOrOptions",
    "OneHotOptions",
    "LogicalAndOptions",
    "LogicalNotOptions",
    "UnpackOptions",
    "FloorDivOptions",
    "SquareOptions",
    "ZerosLikeOptions",
    "FillOptions",
    "BidirectionalSequenceLSTMOptions",
    "BidirectionalSequenceRNNOptions",
    "UnidirectionalSequenceLSTMOptions",
    "FloorModOptions",
    "RangeOptions",
    "ResizeNearestNeighborOptions",
    "LeakyReluOptions",
    "SquaredDifferenceOptions",
    "MirrorPadOptions",
    "AbsOptions",
    "SplitVOptions",
    "UniqueOptions",
    "ReverseV2Options",
    "AddNOptions",
    "GatherNdOptions",
    "CosOptions",
    "WhereOptions",
    "RankOptions",
    "ReverseSequenceOptions",
    "MatrixDiagOptions",
    "QuantizeOptions",
    "MatrixSetDiagOptions",
    "HardSwishOptions",
    "IfOptions",
    "WhileOptions",
    "DepthToSpaceOptions",
    "NonMaxSuppressionV4Options",
    "NonMaxSuppressionV5Options",
    "ScatterNdOptions",
    "SelectV2Options",
    "DensifyOptions",
    "SegmentSumOptions",
    "BatchMatMulOptions",
    "CumsumOptions",
    "CallOnceOptions",
    "BroadcastToOptions",
    "Rfft2dOptions",
    "Conv3DOptions",
    "HashtableOptions",
    "HashtableFindOptions",
    "HashtableImportOptions",
    "HashtableSizeOptions",
    "VarHandleOptions",
    "ReadVariableOptions",
    "AssignVariableOptions",
    "RandomOptions",
    "BucketizeOptions",
    "GeluOptions",
    "DynamicUpdateSliceOptions",
    "UnsortedSegmentProdOptions",
    "UnsortedSegmentMaxOptions",
    "UnsortedSegmentMinOptions",
    "UnsortedSegmentSumOptions",
    "ATan2Options",
    "SignOptions",
    "BitcastOptions",
    "BitwiseXorOptions",
    "RightShiftOptions"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_UNION, 127, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BuiltinOptions2TypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
    { ::flatbuffers::ET_SEQUENCE, 0, 3 },
    { ::flatbuffers::ET_SEQUENCE, 0, 4 },
    { ::flatbuffers::ET_SEQUENCE, 0, 5 },
    { ::flatbuffers::ET_SEQUENCE, 0, 6 },
    { ::flatbuffers::ET_SEQUENCE, 0, 7 },
    { ::flatbuffers::ET_SEQUENCE, 0, 8 },
    { ::flatbuffers::ET_SEQUENCE, 0, 9 },
    { ::flatbuffers::ET_SEQUENCE, 0, 10 },
    { ::flatbuffers::ET_SEQUENCE, 0, 11 },
    { ::flatbuffers::ET_SEQUENCE, 0, 12 },
    { ::flatbuffers::ET_SEQUENCE, 0, 13 },
    { ::flatbuffers::ET_SEQUENCE, 0, 14 },
    { ::flatbuffers::ET_SEQUENCE, 0, 15 },
    { ::flatbuffers::ET_SEQUENCE, 0, 16 },
    { ::flatbuffers::ET_SEQUENCE, 0, 17 },
    { ::flatbuffers::ET_SEQUENCE, 0, 18 },
    { ::flatbuffers::ET_SEQUENCE, 0, 19 },
    { ::flatbuffers::ET_SEQUENCE, 0, 20 },
    { ::flatbuffers::ET_SEQUENCE, 0, 21 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloConcatenateOptionsTypeTable,
    tflite::StablehloBroadcastInDimOptionsTypeTable,
    tflite::StablehloSliceOptionsTypeTable,
    tflite::StablehloConvolutionOptionsTypeTable,
    tflite::StablehloCustomCallOptionsTypeTable,
    tflite::StablehloReduceOptionsTypeTable,
    tflite::StablehloScatterOptionsTypeTable,
    tflite::StablehloCompareOptionsTypeTable,
    tflite::StablehloDynamicSliceOptionsTypeTable,
    tflite::StablehloPadOptionsTypeTable,
    tflite::StablehloIotaOptionsTypeTable,
    tflite::StablehloDotGeneralOptionsTypeTable,
    tflite::StablehloReduceWindowOptionsTypeTable,
    tflite::StablehloSortOptionsTypeTable,
    tflite::StablehloWhileOptionsTypeTable,
    tflite::StablehloGatherOptionsTypeTable,
    tflite::StablehloTransposeOptionsTypeTable,
    tflite::DilateOptionsTypeTable,
    tflite::StablehloRngBitGeneratorOptionsTypeTable,
    tflite::ReduceWindowOptionsTypeTable,
    tflite::StableHLOCompositeOptionsTypeTable,
    tflite::StablehloShiftLeftOptionsTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "StablehloConcatenateOptions",
    "StablehloBroadcastInDimOptions",
    "StablehloSliceOptions",
    "StablehloConvolutionOptions",
    "StablehloCustomCallOptions",
    "StablehloReduceOptions",
    "StablehloScatterOptions",
    "StablehloCompareOptions",
    "StablehloDynamicSliceOptions",
    "StablehloPadOptions",
    "StablehloIotaOptions",
    "StablehloDotGeneralOptions",
    "StablehloReduceWindowOptions",
    "StablehloSortOptions",
    "StablehloWhileOptions",
    "StablehloGatherOptions",
    "StablehloTransposeOptions",
    "DilateOptions",
    "StablehloRngBitGeneratorOptions",
    "ReduceWindowOptions",
    "StableHLOCompositeOptions",
    "StablehloShiftLeftOptions"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_UNION, 23, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloPrecisionConfigTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloPrecisionConfigTypeTable
  };
  static const char * const names[] = {
    "DEFAULT",
    "HIGH",
    "HIGHEST"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloComparisonDirectionTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloComparisonDirectionTypeTable
  };
  static const char * const names[] = {
    "STABLEHLO_COMPARISON_DIRECTION_EQ",
    "STABLEHLO_COMPARISON_DIRECTION_NE",
    "STABLEHLO_COMPARISON_DIRECTION_GE",
    "STABLEHLO_COMPARISON_DIRECTION_GT",
    "STABLEHLO_COMPARISON_DIRECTION_LE",
    "STABLEHLO_COMPARISON_DIRECTION_LT"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloComparisonTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloComparisonTypeTypeTable
  };
  static const char * const names[] = {
    "STABLEHLO_COMPARISON_TYPE_NOTYPE",
    "STABLEHLO_COMPARISON_TYPE_FLOAT",
    "STABLEHLO_COMPARISON_TYPE_FLOAT_TOTAL_ORDER",
    "STABLEHLO_COMPARISON_TYPE_SIGNED",
    "STABLEHLO_COMPARISON_TYPE_UNSIGNED"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RngAlgorithmTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::RngAlgorithmTypeTable
  };
  static const char * const names[] = {
    "DEFAULT",
    "PHILOX",
    "THREEFRY"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *PaddingTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable
  };
  static const char * const names[] = {
    "SAME",
    "VALID"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ActivationFunctionTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "NONE",
    "RELU",
    "RELU_N1_TO_1",
    "RELU6",
    "TANH",
    "SIGN_BIT"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LSHProjectionTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::LSHProjectionTypeTypeTable
  };
  static const char * const names[] = {
    "UNKNOWN",
    "SPARSE",
    "DENSE"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FullyConnectedOptionsWeightsFormatTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::FullyConnectedOptionsWeightsFormatTypeTable
  };
  static const char * const names[] = {
    "DEFAULT",
    "SHUFFLED4x16INT8"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LSTMKernelTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::LSTMKernelTypeTypeTable
  };
  static const char * const names[] = {
    "FULL",
    "BASIC"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CombinerTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::CombinerTypeTypeTable
  };
  static const char * const names[] = {
    "SUM",
    "MEAN",
    "SQRTN"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MirrorPadModeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::MirrorPadModeTypeTable
  };
  static const char * const names[] = {
    "REFLECT",
    "SYMMETRIC"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReduceWindowFunctionTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 },
    { ::flatbuffers::ET_INT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ReduceWindowFunctionTypeTable
  };
  static const char * const names[] = {
    "UNSUPPORTED",
    "ADD",
    "MUL",
    "MINIMUM",
    "MAXIMUM",
    "ALL",
    "ANY"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 7, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CustomOptionsFormatTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::CustomOptionsFormatTypeTable
  };
  static const char * const names[] = {
    "FLEXBUFFERS"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_ENUM, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CustomQuantizationTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const char * const names[] = {
    "custom"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *QuantizationParametersTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 1, -1 },
    { ::flatbuffers::ET_FLOAT, 1, -1 },
    { ::flatbuffers::ET_FLOAT, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_UTYPE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::QuantizationDetailsTypeTable
  };
  static const char * const names[] = {
    "min",
    "max",
    "scale",
    "zero_point",
    "details_type",
    "details",
    "quantized_dimension"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 7, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Int32VectorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 }
  };
  static const char * const names[] = {
    "values"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Uint16VectorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_USHORT, 1, -1 }
  };
  static const char * const names[] = {
    "values"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Uint8VectorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const char * const names[] = {
    "values"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DimensionMetadataTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_UTYPE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_UTYPE, 0, 1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::DimensionTypeTypeTable,
    tflite::SparseIndexVectorTypeTable
  };
  static const char * const names[] = {
    "format",
    "dense_size",
    "array_segments_type",
    "array_segments",
    "array_indices_type",
    "array_indices"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SparsityParametersTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::DimensionMetadataTypeTable
  };
  static const char * const names[] = {
    "traversal_order",
    "block_map",
    "dim_metadata"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *VariantSubTypeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "shape",
    "type",
    "has_rank"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TensorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 3 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable,
    tflite::QuantizationParametersTypeTable,
    tflite::SparsityParametersTypeTable,
    tflite::VariantSubTypeTypeTable
  };
  static const char * const names[] = {
    "shape",
    "type",
    "buffer",
    "name",
    "quantization",
    "is_variable",
    "sparsity",
    "shape_signature",
    "has_rank",
    "variant_tensors"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 10, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloGatherOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "offset_dims",
    "collapsed_slice_dims",
    "start_index_map",
    "index_vector_dim",
    "slice_sizes",
    "indices_are_sorted"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloTransposeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 }
  };
  static const char * const names[] = {
    "permutation"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloDotGeneralOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_UINT, 1, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloPrecisionConfigTypeTable
  };
  static const char * const names[] = {
    "lhs_batching_dimensions",
    "rhs_batching_dimensions",
    "lhs_contracting_dimensions",
    "rhs_contracting_dimensions",
    "precision_config"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloReduceWindowOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "window_dimensions",
    "window_strides",
    "base_dilations",
    "window_dilations",
    "padding",
    "body_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloWhileOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "cond_subgraph_index",
    "body_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloSortOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "dimension",
    "is_stable",
    "comparator_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloConcatenateOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 0, -1 }
  };
  static const char * const names[] = {
    "dimension"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloBroadcastInDimOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 }
  };
  static const char * const names[] = {
    "broadcast_dimensions"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloCompareOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, 0 },
    { ::flatbuffers::ET_UINT, 0, 1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloComparisonDirectionTypeTable,
    tflite::StablehloComparisonTypeTypeTable
  };
  static const char * const names[] = {
    "comparison_direction",
    "compare_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloDynamicSliceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 }
  };
  static const char * const names[] = {
    "slice_sizes"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloPadOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 }
  };
  static const char * const names[] = {
    "edge_padding_low",
    "edge_padding_high",
    "interior_padding"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloIotaOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 0, -1 }
  };
  static const char * const names[] = {
    "iota_dimension"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloCustomCallOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const char * const names[] = {
    "call_target_name",
    "has_side_effect",
    "backend_config",
    "api_version",
    "called_computations",
    "custom_attributes"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloReduceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "dimensions",
    "body_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloSliceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 }
  };
  static const char * const names[] = {
    "start_indices",
    "limit_indices",
    "strides"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloConvolutionOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_BOOL, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_UINT, 1, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::StablehloPrecisionConfigTypeTable
  };
  static const char * const names[] = {
    "window_strides",
    "padding",
    "lhs_dilation",
    "rhs_dilation",
    "window_reversal",
    "input_batch_dimension",
    "input_feature_dimension",
    "input_spatial_dimensions",
    "kernel_input_feature_dimension",
    "kernel_output_feature_dimension",
    "kernel_spatial_dimensions",
    "output_batch_dimension",
    "output_feature_dimension",
    "output_spatial_dimensions",
    "feature_group_count",
    "batch_group_count",
    "precision_config"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 17, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloScatterOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 1, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "indices_are_sorted",
    "update_window_dims",
    "inserted_window_dims",
    "scatter_dims_to_operand_dims",
    "index_vector_dim",
    "unique_indices",
    "update_computation_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 7, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloRngBitGeneratorOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::RngAlgorithmTypeTable
  };
  static const char * const names[] = {
    "algorithm"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Conv2DOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable,
    tflite::ActivationFunctionTypeTypeTable,
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "padding",
    "stride_w",
    "stride_h",
    "fused_activation_function",
    "dilation_w_factor",
    "dilation_h_factor",
    "quantized_bias_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 7, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Conv3DOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable,
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "padding",
    "stride_d",
    "stride_w",
    "stride_h",
    "fused_activation_function",
    "dilation_d_factor",
    "dilation_w_factor",
    "dilation_h_factor"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Pool2DOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable,
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "padding",
    "stride_w",
    "stride_h",
    "filter_width",
    "filter_height",
    "fused_activation_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DepthwiseConv2DOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable,
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "padding",
    "stride_w",
    "stride_h",
    "depth_multiplier",
    "fused_activation_function",
    "dilation_w_factor",
    "dilation_h_factor"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 7, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ConcatEmbeddingsOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_INT, 1, -1 }
  };
  static const char * const names[] = {
    "num_channels",
    "num_columns_per_channel",
    "embedding_dim_per_channel"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LSHProjectionOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::LSHProjectionTypeTypeTable
  };
  static const char * const names[] = {
    "type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SVDFOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "rank",
    "fused_activation_function",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RNNOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SequenceRNNOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "time_major",
    "fused_activation_function",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BidirectionalSequenceRNNOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "time_major",
    "fused_activation_function",
    "merge_outputs",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FullyConnectedOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable,
    tflite::FullyConnectedOptionsWeightsFormatTypeTable,
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "weights_format",
    "keep_num_dims",
    "asymmetric_quantize_inputs",
    "quantized_bias_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SoftmaxOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 0, -1 }
  };
  static const char * const names[] = {
    "beta"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ConcatenationOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "axis",
    "fused_activation_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AddOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "pot_scale_int16"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MulOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *L2NormOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LocalResponseNormalizationOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 }
  };
  static const char * const names[] = {
    "radius",
    "bias",
    "alpha",
    "beta"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LSTMOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable,
    tflite::LSTMKernelTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "cell_clip",
    "proj_clip",
    "kernel_type",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnidirectionalSequenceLSTMOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "cell_clip",
    "proj_clip",
    "time_major",
    "asymmetric_quantize_inputs",
    "diagonal_recurrent_tensors"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BidirectionalSequenceLSTMOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "cell_clip",
    "proj_clip",
    "merge_outputs",
    "time_major",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ResizeBilinearOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "new_height",
    "new_width",
    "align_corners",
    "half_pixel_centers"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ResizeNearestNeighborOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "align_corners",
    "half_pixel_centers"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CallOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, -1 }
  };
  static const char * const names[] = {
    "subgraph"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *PadOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *PadV2OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReshapeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 }
  };
  static const char * const names[] = {
    "new_shape"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SpaceToBatchNDOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BatchToSpaceNDOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SkipGramOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "ngram_size",
    "max_skip_size",
    "include_all_ngrams"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SpaceToDepthOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "block_size"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DepthToSpaceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "block_size"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SubOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function",
    "pot_scale_int16"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DivOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ActivationFunctionTypeTypeTable
  };
  static const char * const names[] = {
    "fused_activation_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TopKV2OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *EmbeddingLookupSparseOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::CombinerTypeTypeTable
  };
  static const char * const names[] = {
    "combiner"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *GatherOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "axis",
    "batch_dims"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TransposeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ExpOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CosOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReducerOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "keep_dims"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SqueezeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 1, -1 }
  };
  static const char * const names[] = {
    "squeeze_dims"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SplitOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "num_splits"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SplitVOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "num_splits"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StridedSliceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "begin_mask",
    "end_mask",
    "ellipsis_mask",
    "new_axis_mask",
    "shrink_axis_mask",
    "offset"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LogSoftmaxOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CastOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "in_data_type",
    "out_data_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DequantizeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MaximumMinimumOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TileOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ArgMaxOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "output_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ArgMinOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "output_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *GreaterOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *GreaterEqualOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LessOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LessEqualOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *NegOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SelectOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SliceOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TransposeConvOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_CHAR, 0, 2 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::PaddingTypeTable,
    tflite::ActivationFunctionTypeTypeTable,
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "padding",
    "stride_w",
    "stride_h",
    "fused_activation_function",
    "quantized_bias_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ExpandDimsOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SparseToDenseOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "validate_indices"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *EqualOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *NotEqualOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ShapeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "out_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RankOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *PowOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FakeQuantOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "min",
    "max",
    "num_bits",
    "narrow_range"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *PackOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "values_count",
    "axis"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LogicalOrOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *OneHotOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "axis"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AbsOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *HardSwishOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LogicalAndOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LogicalNotOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnpackOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "num",
    "axis"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FloorDivOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SquareOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ZerosLikeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FillOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *FloorModOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RangeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *LeakyReluOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 0, -1 }
  };
  static const char * const names[] = {
    "alpha"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SquaredDifferenceOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MirrorPadOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::MirrorPadModeTypeTable
  };
  static const char * const names[] = {
    "mode"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UniqueOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "idx_out_type"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReverseV2OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AddNOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *GatherNdOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *WhereOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReverseSequenceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "seq_dim",
    "batch_dim"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MatrixDiagOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *QuantizeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MatrixSetDiagOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *IfOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "then_subgraph_index",
    "else_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CallOnceOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "init_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *WhileOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "cond_subgraph_index",
    "body_subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *NonMaxSuppressionV4OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *NonMaxSuppressionV5OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ScatterNdOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SelectV2OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DensifyOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SegmentSumOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BatchMatMulOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "adj_x",
    "adj_y",
    "asymmetric_quantize_inputs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *CumsumOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 },
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "exclusive",
    "reverse"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BroadcastToOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *Rfft2dOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *HashtableOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_CHAR, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTypeTable
  };
  static const char * const names[] = {
    "table_id",
    "key_dtype",
    "value_dtype"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *HashtableFindOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *HashtableImportOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *HashtableSizeOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *VarHandleOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 }
  };
  static const char * const names[] = {
    "container",
    "shared_name"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReadVariableOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *AssignVariableOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RandomOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_LONG, 0, -1 },
    { ::flatbuffers::ET_LONG, 0, -1 }
  };
  static const char * const names[] = {
    "seed",
    "seed2"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BucketizeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 1, -1 }
  };
  static const char * const names[] = {
    "boundaries"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *GeluOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_BOOL, 0, -1 }
  };
  static const char * const names[] = {
    "approximate"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DynamicUpdateSliceOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnsortedSegmentProdOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnsortedSegmentMaxOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnsortedSegmentSumOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ATan2OptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *UnsortedSegmentMinOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SignOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BitcastOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BitwiseXorOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *RightShiftOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *DilateOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ReduceWindowOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_INT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::ReduceWindowFunctionTypeTable
  };
  static const char * const names[] = {
    "reduce_function"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *OperatorCodeTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_CHAR, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_INT, 0, 0 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::BuiltinOperatorTypeTable
  };
  static const char * const names[] = {
    "deprecated_builtin_code",
    "custom_code",
    "version",
    "builtin_code"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StableHLOCompositeOptionsTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 },
    { ::flatbuffers::ET_UCHAR, 1, -1 },
    { ::flatbuffers::ET_CHAR, 0, 0 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::CustomOptionsFormatTypeTable
  };
  static const char * const names[] = {
    "name",
    "decomposition_subgraph_index",
    "composite_attributes",
    "composite_attributes_format",
    "version"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *StablehloShiftLeftOptionsTypeTable() {
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *OperatorTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_UTYPE, 0, 0 },
    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
    { ::flatbuffers::ET_UCHAR, 1, -1 },
    { ::flatbuffers::ET_CHAR, 0, 1 },
    { ::flatbuffers::ET_BOOL, 1, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_ULONG, 0, -1 },
    { ::flatbuffers::ET_ULONG, 0, -1 },
    { ::flatbuffers::ET_UTYPE, 0, 2 },
    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::BuiltinOptionsTypeTable,
    tflite::CustomOptionsFormatTypeTable,
    tflite::BuiltinOptions2TypeTable
  };
  static const char * const names[] = {
    "opcode_index",
    "inputs",
    "outputs",
    "builtin_options_type",
    "builtin_options",
    "custom_options",
    "custom_options_format",
    "mutating_variable_inputs",
    "intermediates",
    "large_custom_options_offset",
    "large_custom_options_size",
    "builtin_options_2_type",
    "builtin_options_2",
    "debug_metadata_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 14, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SubGraphTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_INT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorTypeTable,
    tflite::OperatorTypeTable
  };
  static const char * const names[] = {
    "tensors",
    "inputs",
    "outputs",
    "operators",
    "name",
    "debug_metadata_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *BufferTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UCHAR, 1, -1 },
    { ::flatbuffers::ET_ULONG, 0, -1 },
    { ::flatbuffers::ET_ULONG, 0, -1 }
  };
  static const char * const names[] = {
    "data",
    "offset",
    "size"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *MetadataTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_UINT, 0, -1 }
  };
  static const char * const names[] = {
    "name",
    "buffer"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *TensorMapTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_UINT, 0, -1 }
  };
  static const char * const names[] = {
    "name",
    "tensor_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *SignatureDefTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_UINT, 0, -1 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::TensorMapTypeTable
  };
  static const char * const names[] = {
    "inputs",
    "outputs",
    "signature_key",
    "deprecated_tag",
    "subgraph_index"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const ::flatbuffers::TypeTable *ModelTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_UINT, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
    { ::flatbuffers::ET_SEQUENCE, 1, 1 },
    { ::flatbuffers::ET_STRING, 0, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 2 },
    { ::flatbuffers::ET_INT, 1, -1 },
    { ::flatbuffers::ET_SEQUENCE, 1, 3 },
    { ::flatbuffers::ET_SEQUENCE, 1, 4 }
  };
  static const ::flatbuffers::TypeFunction type_refs[] = {
    tflite::OperatorCodeTypeTable,
    tflite::SubGraphTypeTable,
    tflite::BufferTypeTable,
    tflite::MetadataTypeTable,
    tflite::SignatureDefTypeTable
  };
  static const char * const names[] = {
    "version",
    "operator_codes",
    "subgraphs",
    "description",
    "buffers",
    "metadata_buffer",
    "metadata",
    "signature_defs"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 8, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
}

inline const tflite::Model *GetModel(const void *buf) {
  return ::flatbuffers::GetRoot<tflite::Model>(buf);
}

inline const tflite::Model *GetSizePrefixedModel(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
}

inline Model *GetMutableModel(void *buf) {
  return ::flatbuffers::GetMutableRoot<Model>(buf);
}

inline tflite::Model *GetMutableSizePrefixedModel(void *buf) {
  return ::flatbuffers::GetMutableSizePrefixedRoot<tflite::Model>(buf);
}

inline const char *ModelIdentifier() {
  return "TFL3";
}

inline bool ModelBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, ModelIdentifier());
}

inline bool SizePrefixedModelBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, ModelIdentifier(), true);
}

inline bool VerifyModelBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
}

inline bool VerifySizePrefixedModelBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
}

inline const char *ModelExtension() {
  return "tflite";
}

inline void FinishModelBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tflite::Model> root) {
  fbb.Finish(root, ModelIdentifier());
}

inline void FinishSizePrefixedModelBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tflite::Model> root) {
  fbb.FinishSizePrefixed(root, ModelIdentifier());
}

}  // namespace tflite

#endif  // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
