runtime/onert/frontend/tflite/src/tflite_schema_generated.h

   1 /*
   2  * Copyright (c) 2019-2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  * Copyright 2018 The TensorFlow Authors. All Rights Reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 // automatically generated by the FlatBuffers compiler, do not modify
  19
  20 #ifndef FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_
  21 #define FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_
  22
  23 #include "flatbuffers/flatbuffers.h"
  24
  25 namespace onert_tflite
  26 {
  27
  28 struct CustomQuantization;
  29
  30 struct QuantizationParameters;
  31
  32 struct Int32Vector;
  33
  34 struct Uint16Vector;
  35
  36 struct Uint8Vector;
  37
  38 struct DimensionMetadata;
  39
  40 struct SparsityParameters;
  41
  42 struct Tensor;
  43
  44 struct Conv2DOptions;
  45
  46 struct Pool2DOptions;
  47
  48 struct DepthwiseConv2DOptions;
  49
  50 struct ConcatEmbeddingsOptions;
  51
  52 struct LSHProjectionOptions;
  53
  54 struct SVDFOptions;
  55
  56 struct RNNOptions;
  57
  58 struct SequenceRNNOptions;
  59
  60 struct BidirectionalSequenceRNNOptions;
  61
  62 struct FullyConnectedOptions;
  63
  64 struct SoftmaxOptions;
  65
  66 struct ConcatenationOptions;
  67
  68 struct AddOptions;
  69
  70 struct MulOptions;
  71
  72 struct L2NormOptions;
  73
  74 struct LocalResponseNormalizationOptions;
  75
  76 struct LSTMOptions;
  77
  78 struct UnidirectionalSequenceLSTMOptions;
  79
  80 struct BidirectionalSequenceLSTMOptions;
  81
  82 struct ResizeBilinearOptions;
  83
  84 struct ResizeNearestNeighborOptions;
  85
  86 struct CallOptions;
  87
  88 struct PadOptions;
  89
  90 struct PadV2Options;
  91
  92 struct ReshapeOptions;
  93
  94 struct SpaceToBatchNDOptions;
  95
  96 struct BatchToSpaceNDOptions;
  97
  98 struct SkipGramOptions;
  99
 100 struct SpaceToDepthOptions;
 101
 102 struct DepthToSpaceOptions;
 103
 104 struct SubOptions;
 105
 106 struct DivOptions;
 107
 108 struct TopKV2Options;
 109
 110 struct EmbeddingLookupSparseOptions;
 111
 112 struct GatherOptions;
 113
 114 struct TransposeOptions;
 115
 116 struct ExpOptions;
 117
 118 struct CosOptions;
 119
 120 struct ReducerOptions;
 121
 122 struct SqueezeOptions;
 123
 124 struct SplitOptions;
 125
 126 struct SplitVOptions;
 127
 128 struct StridedSliceOptions;
 129
 130 struct LogSoftmaxOptions;
 131
 132 struct CastOptions;
 133
 134 struct DequantizeOptions;
 135
 136 struct MaximumMinimumOptions;
 137
 138 struct TileOptions;
 139
 140 struct ArgMaxOptions;
 141
 142 struct ArgMinOptions;
 143
 144 struct GreaterOptions;
 145
 146 struct GreaterEqualOptions;
 147
 148 struct LessOptions;
 149
 150 struct LessEqualOptions;
 151
 152 struct NegOptions;
 153
 154 struct SelectOptions;
 155
 156 struct SliceOptions;
 157
 158 struct TransposeConvOptions;
 159
 160 struct ExpandDimsOptions;
 161
 162 struct SparseToDenseOptions;
 163
 164 struct EqualOptions;
 165
 166 struct NotEqualOptions;
 167
 168 struct ShapeOptions;
 169
 170 struct RankOptions;
 171
 172 struct PowOptions;
 173
 174 struct FakeQuantOptions;
 175
 176 struct PackOptions;
 177
 178 struct LogicalOrOptions;
 179
 180 struct OneHotOptions;
 181
 182 struct AbsOptions;
 183
 184 struct HardSwishOptions;
 185
 186 struct LogicalAndOptions;
 187
 188 struct LogicalNotOptions;
 189
 190 struct UnpackOptions;
 191
 192 struct FloorDivOptions;
 193
 194 struct SquareOptions;
 195
 196 struct ZerosLikeOptions;
 197
 198 struct FillOptions;
 199
 200 struct FloorModOptions;
 201
 202 struct RangeOptions;
 203
 204 struct LeakyReluOptions;
 205
 206 struct SquaredDifferenceOptions;
 207
 208 struct MirrorPadOptions;
 209
 210 struct UniqueOptions;
 211
 212 struct ReverseV2Options;
 213
 214 struct AddNOptions;
 215
 216 struct GatherNdOptions;
 217
 218 struct WhereOptions;
 219
 220 struct ReverseSequenceOptions;
 221
 222 struct MatrixDiagOptions;
 223
 224 struct QuantizeOptions;
 225
 226 struct MatrixSetDiagOptions;
 227
 228 struct IfOptions;
 229
 230 struct WhileOptions;
 231
 232 struct NonMaxSuppressionV4Options;
 233
 234 struct NonMaxSuppressionV5Options;
 235
 236 struct ScatterNdOptions;
 237
 238 struct SelectV2Options;
 239
 240 struct DensifyOptions;
 241
 242 struct SegmentSumOptions;
 243
 244 struct BatchMatMulOptions;
 245
 246 struct OperatorCode;
 247
 248 struct Operator;
 249
 250 struct SubGraph;
 251
 252 struct Buffer;
 253
 254 struct Metadata;
 255
 256 struct Model;
 257
 258 enum TensorType
 259 {
 260   TensorType_FLOAT32 = 0,
 261   TensorType_FLOAT16 = 1,
 262   TensorType_INT32 = 2,
 263   TensorType_UINT8 = 3,
 264   TensorType_INT64 = 4,
 265   TensorType_STRING = 5,
 266   TensorType_BOOL = 6,
 267   TensorType_INT16 = 7,
 268   TensorType_COMPLEX64 = 8,
 269   TensorType_INT8 = 9,
 270   TensorType_FLOAT64 = 10,
 271   TensorType_MIN = TensorType_FLOAT32,
 272   TensorType_MAX = TensorType_FLOAT64
 273 };
 274
 275 inline const TensorType (&EnumValuesTensorType())[11]
 276 {
 277   static const TensorType values[] = {TensorType_FLOAT32, TensorType_FLOAT16, TensorType_INT32,
 278                                       TensorType_UINT8,   TensorType_INT64,   TensorType_STRING,
 279                                       TensorType_BOOL,    TensorType_INT16,   TensorType_COMPLEX64,
 280                                       TensorType_INT8,    TensorType_FLOAT64};
 281   return values;
 282 }
 283
 284 inline const char *const *EnumNamesTensorType()
 285 {
 286   static const char *const names[] = {"FLOAT32",   "FLOAT16", "INT32",   "UINT8",
 287                                       "INT64",     "STRING",  "BOOL",    "INT16",
 288                                       "COMPLEX64", "INT8",    "FLOAT64", nullptr};
 289   return names;
 290 }
 291
 292 inline const char *EnumNameTensorType(TensorType e)
 293 {
 294   const size_t index = static_cast<int>(e);
 295   return EnumNamesTensorType()[index];
 296 }
 297
 298 enum QuantizationDetails
 299 {
 300   QuantizationDetails_NONE = 0,
 301   QuantizationDetails_CustomQuantization = 1,
 302   QuantizationDetails_MIN = QuantizationDetails_NONE,
 303   QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
 304 };
 305
 306 inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2]
 307 {
 308   static const QuantizationDetails values[] = {QuantizationDetails_NONE,
 309                                                QuantizationDetails_CustomQuantization};
 310   return values;
 311 }
 312
 313 inline const char *const *EnumNamesQuantizationDetails()
 314 {
 315   static const char *const names[] = {"NONE", "CustomQuantization", nullptr};
 316   return names;
 317 }
 318
 319 inline const char *EnumNameQuantizationDetails(QuantizationDetails e)
 320 {
 321   const size_t index = static_cast<int>(e);
 322   return EnumNamesQuantizationDetails()[index];
 323 }
 324
 325 template <typename T> struct QuantizationDetailsTraits
 326 {
 327   static const QuantizationDetails enum_value = QuantizationDetails_NONE;
 328 };
 329
 330 template <> struct QuantizationDetailsTraits<CustomQuantization>
 331 {
 332   static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
 333 };
 334
 335 bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
 336                                QuantizationDetails type);
 337 bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
 338                                      const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 339                                      const flatbuffers::Vector<uint8_t> *types);
 340
 341 enum DimensionType
 342 {
 343   DimensionType_DENSE = 0,
 344   DimensionType_SPARSE_CSR = 1,
 345   DimensionType_MIN = DimensionType_DENSE,
 346   DimensionType_MAX = DimensionType_SPARSE_CSR
 347 };
 348
 349 inline const DimensionType (&EnumValuesDimensionType())[2]
 350 {
 351   static const DimensionType values[] = {DimensionType_DENSE, DimensionType_SPARSE_CSR};
 352   return values;
 353 }
 354
 355 inline const char *const *EnumNamesDimensionType()
 356 {
 357   static const char *const names[] = {"DENSE", "SPARSE_CSR", nullptr};
 358   return names;
 359 }
 360
 361 inline const char *EnumNameDimensionType(DimensionType e)
 362 {
 363   const size_t index = static_cast<int>(e);
 364   return EnumNamesDimensionType()[index];
 365 }
 366
 367 enum SparseIndexVector
 368 {
 369   SparseIndexVector_NONE = 0,
 370   SparseIndexVector_Int32Vector = 1,
 371   SparseIndexVector_Uint16Vector = 2,
 372   SparseIndexVector_Uint8Vector = 3,
 373   SparseIndexVector_MIN = SparseIndexVector_NONE,
 374   SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
 375 };
 376
 377 inline const SparseIndexVector (&EnumValuesSparseIndexVector())[4]
 378 {
 379   static const SparseIndexVector values[] = {SparseIndexVector_NONE, SparseIndexVector_Int32Vector,
 380                                              SparseIndexVector_Uint16Vector,
 381                                              SparseIndexVector_Uint8Vector};
 382   return values;
 383 }
 384
 385 inline const char *const *EnumNamesSparseIndexVector()
 386 {
 387   static const char *const names[] = {"NONE", "Int32Vector", "Uint16Vector", "Uint8Vector",
 388                                       nullptr};
 389   return names;
 390 }
 391
 392 inline const char *EnumNameSparseIndexVector(SparseIndexVector e)
 393 {
 394   const size_t index = static_cast<int>(e);
 395   return EnumNamesSparseIndexVector()[index];
 396 }
 397
 398 template <typename T> struct SparseIndexVectorTraits
 399 {
 400   static const SparseIndexVector enum_value = SparseIndexVector_NONE;
 401 };
 402
 403 template <> struct SparseIndexVectorTraits<Int32Vector>
 404 {
 405   static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
 406 };
 407
 408 template <> struct SparseIndexVectorTraits<Uint16Vector>
 409 {
 410   static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
 411 };
 412
 413 template <> struct SparseIndexVectorTraits<Uint8Vector>
 414 {
 415   static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
 416 };
 417
 418 bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
 419                              SparseIndexVector type);
 420 bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
 421                                    const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 422                                    const flatbuffers::Vector<uint8_t> *types);
 423
 424 enum BuiltinOperator
 425 {
 426   BuiltinOperator_ADD = 0,
 427   BuiltinOperator_AVERAGE_POOL_2D = 1,
 428   BuiltinOperator_CONCATENATION = 2,
 429   BuiltinOperator_CONV_2D = 3,
 430   BuiltinOperator_DEPTHWISE_CONV_2D = 4,
 431   BuiltinOperator_DEPTH_TO_SPACE = 5,
 432   BuiltinOperator_DEQUANTIZE = 6,
 433   BuiltinOperator_EMBEDDING_LOOKUP = 7,
 434   BuiltinOperator_FLOOR = 8,
 435   BuiltinOperator_FULLY_CONNECTED = 9,
 436   BuiltinOperator_HASHTABLE_LOOKUP = 10,
 437   BuiltinOperator_L2_NORMALIZATION = 11,
 438   BuiltinOperator_L2_POOL_2D = 12,
 439   BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13,
 440   BuiltinOperator_LOGISTIC = 14,
 441   BuiltinOperator_LSH_PROJECTION = 15,
 442   BuiltinOperator_LSTM = 16,
 443   BuiltinOperator_MAX_POOL_2D = 17,
 444   BuiltinOperator_MUL = 18,
 445   BuiltinOperator_RELU = 19,
 446   BuiltinOperator_RELU_N1_TO_1 = 20,
 447   BuiltinOperator_RELU6 = 21,
 448   BuiltinOperator_RESHAPE = 22,
 449   BuiltinOperator_RESIZE_BILINEAR = 23,
 450   BuiltinOperator_RNN = 24,
 451   BuiltinOperator_SOFTMAX = 25,
 452   BuiltinOperator_SPACE_TO_DEPTH = 26,
 453   BuiltinOperator_SVDF = 27,
 454   BuiltinOperator_TANH = 28,
 455   BuiltinOperator_CONCAT_EMBEDDINGS = 29,
 456   BuiltinOperator_SKIP_GRAM = 30,
 457   BuiltinOperator_CALL = 31,
 458   BuiltinOperator_CUSTOM = 32,
 459   BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33,
 460   BuiltinOperator_PAD = 34,
 461   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35,
 462   BuiltinOperator_GATHER = 36,
 463   BuiltinOperator_BATCH_TO_SPACE_ND = 37,
 464   BuiltinOperator_SPACE_TO_BATCH_ND = 38,
 465   BuiltinOperator_TRANSPOSE = 39,
 466   BuiltinOperator_MEAN = 40,
 467   BuiltinOperator_SUB = 41,
 468   BuiltinOperator_DIV = 42,
 469   BuiltinOperator_SQUEEZE = 43,
 470   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
 471   BuiltinOperator_STRIDED_SLICE = 45,
 472   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
 473   BuiltinOperator_EXP = 47,
 474   BuiltinOperator_TOPK_V2 = 48,
 475   BuiltinOperator_SPLIT = 49,
 476   BuiltinOperator_LOG_SOFTMAX = 50,
 477   BuiltinOperator_DELEGATE = 51,
 478   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52,
 479   BuiltinOperator_CAST = 53,
 480   BuiltinOperator_PRELU = 54,
 481   BuiltinOperator_MAXIMUM = 55,
 482   BuiltinOperator_ARG_MAX = 56,
 483   BuiltinOperator_MINIMUM = 57,
 484   BuiltinOperator_LESS = 58,
 485   BuiltinOperator_NEG = 59,
 486   BuiltinOperator_PADV2 = 60,
 487   BuiltinOperator_GREATER = 61,
 488   BuiltinOperator_GREATER_EQUAL = 62,
 489   BuiltinOperator_LESS_EQUAL = 63,
 490   BuiltinOperator_SELECT = 64,
 491   BuiltinOperator_SLICE = 65,
 492   BuiltinOperator_SIN = 66,
 493   BuiltinOperator_TRANSPOSE_CONV = 67,
 494   BuiltinOperator_SPARSE_TO_DENSE = 68,
 495   BuiltinOperator_TILE = 69,
 496   BuiltinOperator_EXPAND_DIMS = 70,
 497   BuiltinOperator_EQUAL = 71,
 498   BuiltinOperator_NOT_EQUAL = 72,
 499   BuiltinOperator_LOG = 73,
 500   BuiltinOperator_SUM = 74,
 501   BuiltinOperator_SQRT = 75,
 502   BuiltinOperator_RSQRT = 76,
 503   BuiltinOperator_SHAPE = 77,
 504   BuiltinOperator_POW = 78,
 505   BuiltinOperator_ARG_MIN = 79,
 506   BuiltinOperator_FAKE_QUANT = 80,
 507   BuiltinOperator_REDUCE_PROD = 81,
 508   BuiltinOperator_REDUCE_MAX = 82,
 509   BuiltinOperator_PACK = 83,
 510   BuiltinOperator_LOGICAL_OR = 84,
 511   BuiltinOperator_ONE_HOT = 85,
 512   BuiltinOperator_LOGICAL_AND = 86,
 513   BuiltinOperator_LOGICAL_NOT = 87,
 514   BuiltinOperator_UNPACK = 88,
 515   BuiltinOperator_REDUCE_MIN = 89,
 516   BuiltinOperator_FLOOR_DIV = 90,
 517   BuiltinOperator_REDUCE_ANY = 91,
 518   BuiltinOperator_SQUARE = 92,
 519   BuiltinOperator_ZEROS_LIKE = 93,
 520   BuiltinOperator_FILL = 94,
 521   BuiltinOperator_FLOOR_MOD = 95,
 522   BuiltinOperator_RANGE = 96,
 523   BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97,
 524   BuiltinOperator_LEAKY_RELU = 98,
 525   BuiltinOperator_SQUARED_DIFFERENCE = 99,
 526   BuiltinOperator_MIRROR_PAD = 100,
 527   BuiltinOperator_ABS = 101,
 528   BuiltinOperator_SPLIT_V = 102,
 529   BuiltinOperator_UNIQUE = 103,
 530   BuiltinOperator_CEIL = 104,
 531   BuiltinOperator_REVERSE_V2 = 105,
 532   BuiltinOperator_ADD_N = 106,
 533   BuiltinOperator_GATHER_ND = 107,
 534   BuiltinOperator_COS = 108,
 535   BuiltinOperator_WHERE = 109,
 536   BuiltinOperator_RANK = 110,
 537   BuiltinOperator_ELU = 111,
 538   BuiltinOperator_REVERSE_SEQUENCE = 112,
 539   BuiltinOperator_MATRIX_DIAG = 113,
 540   BuiltinOperator_QUANTIZE = 114,
 541   BuiltinOperator_MATRIX_SET_DIAG = 115,
 542   BuiltinOperator_ROUND = 116,
 543   BuiltinOperator_HARD_SWISH = 117,
 544   BuiltinOperator_IF = 118,
 545   BuiltinOperator_WHILE = 119,
 546   BuiltinOperator_NON_MAX_SUPPRESSION_V4 = 120,
 547   BuiltinOperator_NON_MAX_SUPPRESSION_V5 = 121,
 548   BuiltinOperator_SCATTER_ND = 122,
 549   BuiltinOperator_SELECT_V2 = 123,
 550   BuiltinOperator_DENSIFY = 124,
 551   BuiltinOperator_SEGMENT_SUM = 125,
 552   BuiltinOperator_BATCH_MATMUL = 126,
 553   BuiltinOperator_MIN = BuiltinOperator_ADD,
 554   BuiltinOperator_MAX = BuiltinOperator_BATCH_MATMUL
 555 };
 556
 557 inline const BuiltinOperator (&EnumValuesBuiltinOperator())[127]
 558 {
 559   static const BuiltinOperator values[] = {BuiltinOperator_ADD,
 560                                            BuiltinOperator_AVERAGE_POOL_2D,
 561                                            BuiltinOperator_CONCATENATION,
 562                                            BuiltinOperator_CONV_2D,
 563                                            BuiltinOperator_DEPTHWISE_CONV_2D,
 564                                            BuiltinOperator_DEPTH_TO_SPACE,
 565                                            BuiltinOperator_DEQUANTIZE,
 566                                            BuiltinOperator_EMBEDDING_LOOKUP,
 567                                            BuiltinOperator_FLOOR,
 568                                            BuiltinOperator_FULLY_CONNECTED,
 569                                            BuiltinOperator_HASHTABLE_LOOKUP,
 570                                            BuiltinOperator_L2_NORMALIZATION,
 571                                            BuiltinOperator_L2_POOL_2D,
 572                                            BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
 573                                            BuiltinOperator_LOGISTIC,
 574                                            BuiltinOperator_LSH_PROJECTION,
 575                                            BuiltinOperator_LSTM,
 576                                            BuiltinOperator_MAX_POOL_2D,
 577                                            BuiltinOperator_MUL,
 578                                            BuiltinOperator_RELU,
 579                                            BuiltinOperator_RELU_N1_TO_1,
 580                                            BuiltinOperator_RELU6,
 581                                            BuiltinOperator_RESHAPE,
 582                                            BuiltinOperator_RESIZE_BILINEAR,
 583                                            BuiltinOperator_RNN,
 584                                            BuiltinOperator_SOFTMAX,
 585                                            BuiltinOperator_SPACE_TO_DEPTH,
 586                                            BuiltinOperator_SVDF,
 587                                            BuiltinOperator_TANH,
 588                                            BuiltinOperator_CONCAT_EMBEDDINGS,
 589                                            BuiltinOperator_SKIP_GRAM,
 590                                            BuiltinOperator_CALL,
 591                                            BuiltinOperator_CUSTOM,
 592                                            BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
 593                                            BuiltinOperator_PAD,
 594                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
 595                                            BuiltinOperator_GATHER,
 596                                            BuiltinOperator_BATCH_TO_SPACE_ND,
 597                                            BuiltinOperator_SPACE_TO_BATCH_ND,
 598                                            BuiltinOperator_TRANSPOSE,
 599                                            BuiltinOperator_MEAN,
 600                                            BuiltinOperator_SUB,
 601                                            BuiltinOperator_DIV,
 602                                            BuiltinOperator_SQUEEZE,
 603                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
 604                                            BuiltinOperator_STRIDED_SLICE,
 605                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
 606                                            BuiltinOperator_EXP,
 607                                            BuiltinOperator_TOPK_V2,
 608                                            BuiltinOperator_SPLIT,
 609                                            BuiltinOperator_LOG_SOFTMAX,
 610                                            BuiltinOperator_DELEGATE,
 611                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
 612                                            BuiltinOperator_CAST,
 613                                            BuiltinOperator_PRELU,
 614                                            BuiltinOperator_MAXIMUM,
 615                                            BuiltinOperator_ARG_MAX,
 616                                            BuiltinOperator_MINIMUM,
 617                                            BuiltinOperator_LESS,
 618                                            BuiltinOperator_NEG,
 619                                            BuiltinOperator_PADV2,
 620                                            BuiltinOperator_GREATER,
 621                                            BuiltinOperator_GREATER_EQUAL,
 622                                            BuiltinOperator_LESS_EQUAL,
 623                                            BuiltinOperator_SELECT,
 624                                            BuiltinOperator_SLICE,
 625                                            BuiltinOperator_SIN,
 626                                            BuiltinOperator_TRANSPOSE_CONV,
 627                                            BuiltinOperator_SPARSE_TO_DENSE,
 628                                            BuiltinOperator_TILE,
 629                                            BuiltinOperator_EXPAND_DIMS,
 630                                            BuiltinOperator_EQUAL,
 631                                            BuiltinOperator_NOT_EQUAL,
 632                                            BuiltinOperator_LOG,
 633                                            BuiltinOperator_SUM,
 634                                            BuiltinOperator_SQRT,
 635                                            BuiltinOperator_RSQRT,
 636                                            BuiltinOperator_SHAPE,
 637                                            BuiltinOperator_POW,
 638                                            BuiltinOperator_ARG_MIN,
 639                                            BuiltinOperator_FAKE_QUANT,
 640                                            BuiltinOperator_REDUCE_PROD,
 641                                            BuiltinOperator_REDUCE_MAX,
 642                                            BuiltinOperator_PACK,
 643                                            BuiltinOperator_LOGICAL_OR,
 644                                            BuiltinOperator_ONE_HOT,
 645                                            BuiltinOperator_LOGICAL_AND,
 646                                            BuiltinOperator_LOGICAL_NOT,
 647                                            BuiltinOperator_UNPACK,
 648                                            BuiltinOperator_REDUCE_MIN,
 649                                            BuiltinOperator_FLOOR_DIV,
 650                                            BuiltinOperator_REDUCE_ANY,
 651                                            BuiltinOperator_SQUARE,
 652                                            BuiltinOperator_ZEROS_LIKE,
 653                                            BuiltinOperator_FILL,
 654                                            BuiltinOperator_FLOOR_MOD,
 655                                            BuiltinOperator_RANGE,
 656                                            BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
 657                                            BuiltinOperator_LEAKY_RELU,
 658                                            BuiltinOperator_SQUARED_DIFFERENCE,
 659                                            BuiltinOperator_MIRROR_PAD,
 660                                            BuiltinOperator_ABS,
 661                                            BuiltinOperator_SPLIT_V,
 662                                            BuiltinOperator_UNIQUE,
 663                                            BuiltinOperator_CEIL,
 664                                            BuiltinOperator_REVERSE_V2,
 665                                            BuiltinOperator_ADD_N,
 666                                            BuiltinOperator_GATHER_ND,
 667                                            BuiltinOperator_COS,
 668                                            BuiltinOperator_WHERE,
 669                                            BuiltinOperator_RANK,
 670                                            BuiltinOperator_ELU,
 671                                            BuiltinOperator_REVERSE_SEQUENCE,
 672                                            BuiltinOperator_MATRIX_DIAG,
 673                                            BuiltinOperator_QUANTIZE,
 674                                            BuiltinOperator_MATRIX_SET_DIAG,
 675                                            BuiltinOperator_ROUND,
 676                                            BuiltinOperator_HARD_SWISH,
 677                                            BuiltinOperator_IF,
 678                                            BuiltinOperator_WHILE,
 679                                            BuiltinOperator_NON_MAX_SUPPRESSION_V4,
 680                                            BuiltinOperator_NON_MAX_SUPPRESSION_V5,
 681                                            BuiltinOperator_SCATTER_ND,
 682                                            BuiltinOperator_SELECT_V2,
 683                                            BuiltinOperator_DENSIFY,
 684                                            BuiltinOperator_SEGMENT_SUM,
 685                                            BuiltinOperator_BATCH_MATMUL};
 686   return values;
 687 }
 688
 689 inline const char *const *EnumNamesBuiltinOperator()
 690 {
 691   static const char *const names[] = {"ADD",
 692                                       "AVERAGE_POOL_2D",
 693                                       "CONCATENATION",
 694                                       "CONV_2D",
 695                                       "DEPTHWISE_CONV_2D",
 696                                       "DEPTH_TO_SPACE",
 697                                       "DEQUANTIZE",
 698                                       "EMBEDDING_LOOKUP",
 699                                       "FLOOR",
 700                                       "FULLY_CONNECTED",
 701                                       "HASHTABLE_LOOKUP",
 702                                       "L2_NORMALIZATION",
 703                                       "L2_POOL_2D",
 704                                       "LOCAL_RESPONSE_NORMALIZATION",
 705                                       "LOGISTIC",
 706                                       "LSH_PROJECTION",
 707                                       "LSTM",
 708                                       "MAX_POOL_2D",
 709                                       "MUL",
 710                                       "RELU",
 711                                       "RELU_N1_TO_1",
 712                                       "RELU6",
 713                                       "RESHAPE",
 714                                       "RESIZE_BILINEAR",
 715                                       "RNN",
 716                                       "SOFTMAX",
 717                                       "SPACE_TO_DEPTH",
 718                                       "SVDF",
 719                                       "TANH",
 720                                       "CONCAT_EMBEDDINGS",
 721                                       "SKIP_GRAM",
 722                                       "CALL",
 723                                       "CUSTOM",
 724                                       "EMBEDDING_LOOKUP_SPARSE",
 725                                       "PAD",
 726                                       "UNIDIRECTIONAL_SEQUENCE_RNN",
 727                                       "GATHER",
 728                                       "BATCH_TO_SPACE_ND",
 729                                       "SPACE_TO_BATCH_ND",
 730                                       "TRANSPOSE",
 731                                       "MEAN",
 732                                       "SUB",
 733                                       "DIV",
 734                                       "SQUEEZE",
 735                                       "UNIDIRECTIONAL_SEQUENCE_LSTM",
 736                                       "STRIDED_SLICE",
 737                                       "BIDIRECTIONAL_SEQUENCE_RNN",
 738                                       "EXP",
 739                                       "TOPK_V2",
 740                                       "SPLIT",
 741                                       "LOG_SOFTMAX",
 742                                       "DELEGATE",
 743                                       "BIDIRECTIONAL_SEQUENCE_LSTM",
 744                                       "CAST",
 745                                       "PRELU",
 746                                       "MAXIMUM",
 747                                       "ARG_MAX",
 748                                       "MINIMUM",
 749                                       "LESS",
 750                                       "NEG",
 751                                       "PADV2",
 752                                       "GREATER",
 753                                       "GREATER_EQUAL",
 754                                       "LESS_EQUAL",
 755                                       "SELECT",
 756                                       "SLICE",
 757                                       "SIN",
 758                                       "TRANSPOSE_CONV",
 759                                       "SPARSE_TO_DENSE",
 760                                       "TILE",
 761                                       "EXPAND_DIMS",
 762                                       "EQUAL",
 763                                       "NOT_EQUAL",
 764                                       "LOG",
 765                                       "SUM",
 766                                       "SQRT",
 767                                       "RSQRT",
 768                                       "SHAPE",
 769                                       "POW",
 770                                       "ARG_MIN",
 771                                       "FAKE_QUANT",
 772                                       "REDUCE_PROD",
 773                                       "REDUCE_MAX",
 774                                       "PACK",
 775                                       "LOGICAL_OR",
 776                                       "ONE_HOT",
 777                                       "LOGICAL_AND",
 778                                       "LOGICAL_NOT",
 779                                       "UNPACK",
 780                                       "REDUCE_MIN",
 781                                       "FLOOR_DIV",
 782                                       "REDUCE_ANY",
 783                                       "SQUARE",
 784                                       "ZEROS_LIKE",
 785                                       "FILL",
 786                                       "FLOOR_MOD",
 787                                       "RANGE",
 788                                       "RESIZE_NEAREST_NEIGHBOR",
 789                                       "LEAKY_RELU",
 790                                       "SQUARED_DIFFERENCE",
 791                                       "MIRROR_PAD",
 792                                       "ABS",
 793                                       "SPLIT_V",
 794                                       "UNIQUE",
 795                                       "CEIL",
 796                                       "REVERSE_V2",
 797                                       "ADD_N",
 798                                       "GATHER_ND",
 799                                       "COS",
 800                                       "WHERE",
 801                                       "RANK",
 802                                       "ELU",
 803                                       "REVERSE_SEQUENCE",
 804                                       "MATRIX_DIAG",
 805                                       "QUANTIZE",
 806                                       "MATRIX_SET_DIAG",
 807                                       "ROUND",
 808                                       "HARD_SWISH",
 809                                       "IF",
 810                                       "WHILE",
 811                                       "NON_MAX_SUPPRESSION_V4",
 812                                       "NON_MAX_SUPPRESSION_V5",
 813                                       "SCATTER_ND",
 814                                       "SELECT_V2",
 815                                       "DENSIFY",
 816                                       "SEGMENT_SUM",
 817                                       "BATCH_MATMUL",
 818                                       nullptr};
 819   return names;
 820 }
 821
 822 inline const char *EnumNameBuiltinOperator(BuiltinOperator e)
 823 {
 824   const size_t index = static_cast<int>(e);
 825   return EnumNamesBuiltinOperator()[index];
 826 }
 827
 828 enum BuiltinOptions
 829 {
 830   BuiltinOptions_NONE = 0,
 831   BuiltinOptions_Conv2DOptions = 1,
 832   BuiltinOptions_DepthwiseConv2DOptions = 2,
 833   BuiltinOptions_ConcatEmbeddingsOptions = 3,
 834   BuiltinOptions_LSHProjectionOptions = 4,
 835   BuiltinOptions_Pool2DOptions = 5,
 836   BuiltinOptions_SVDFOptions = 6,
 837   BuiltinOptions_RNNOptions = 7,
 838   BuiltinOptions_FullyConnectedOptions = 8,
 839   BuiltinOptions_SoftmaxOptions = 9,
 840   BuiltinOptions_ConcatenationOptions = 10,
 841   BuiltinOptions_AddOptions = 11,
 842   BuiltinOptions_L2NormOptions = 12,
 843   BuiltinOptions_LocalResponseNormalizationOptions = 13,
 844   BuiltinOptions_LSTMOptions = 14,
 845   BuiltinOptions_ResizeBilinearOptions = 15,
 846   BuiltinOptions_CallOptions = 16,
 847   BuiltinOptions_ReshapeOptions = 17,
 848   BuiltinOptions_SkipGramOptions = 18,
 849   BuiltinOptions_SpaceToDepthOptions = 19,
 850   BuiltinOptions_EmbeddingLookupSparseOptions = 20,
 851   BuiltinOptions_MulOptions = 21,
 852   BuiltinOptions_PadOptions = 22,
 853   BuiltinOptions_GatherOptions = 23,
 854   BuiltinOptions_BatchToSpaceNDOptions = 24,
 855   BuiltinOptions_SpaceToBatchNDOptions = 25,
 856   BuiltinOptions_TransposeOptions = 26,
 857   BuiltinOptions_ReducerOptions = 27,
 858   BuiltinOptions_SubOptions = 28,
 859   BuiltinOptions_DivOptions = 29,
 860   BuiltinOptions_SqueezeOptions = 30,
 861   BuiltinOptions_SequenceRNNOptions = 31,
 862   BuiltinOptions_StridedSliceOptions = 32,
 863   BuiltinOptions_ExpOptions = 33,
 864   BuiltinOptions_TopKV2Options = 34,
 865   BuiltinOptions_SplitOptions = 35,
 866   BuiltinOptions_LogSoftmaxOptions = 36,
 867   BuiltinOptions_CastOptions = 37,
 868   BuiltinOptions_DequantizeOptions = 38,
 869   BuiltinOptions_MaximumMinimumOptions = 39,
 870   BuiltinOptions_ArgMaxOptions = 40,
 871   BuiltinOptions_LessOptions = 41,
 872   BuiltinOptions_NegOptions = 42,
 873   BuiltinOptions_PadV2Options = 43,
 874   BuiltinOptions_GreaterOptions = 44,
 875   BuiltinOptions_GreaterEqualOptions = 45,
 876   BuiltinOptions_LessEqualOptions = 46,
 877   BuiltinOptions_SelectOptions = 47,
 878   BuiltinOptions_SliceOptions = 48,
 879   BuiltinOptions_TransposeConvOptions = 49,
 880   BuiltinOptions_SparseToDenseOptions = 50,
 881   BuiltinOptions_TileOptions = 51,
 882   BuiltinOptions_ExpandDimsOptions = 52,
 883   BuiltinOptions_EqualOptions = 53,
 884   BuiltinOptions_NotEqualOptions = 54,
 885   BuiltinOptions_ShapeOptions = 55,
 886   BuiltinOptions_PowOptions = 56,
 887   BuiltinOptions_ArgMinOptions = 57,
 888   BuiltinOptions_FakeQuantOptions = 58,
 889   BuiltinOptions_PackOptions = 59,
 890   BuiltinOptions_LogicalOrOptions = 60,
 891   BuiltinOptions_OneHotOptions = 61,
 892   BuiltinOptions_LogicalAndOptions = 62,
 893   BuiltinOptions_LogicalNotOptions = 63,
 894   BuiltinOptions_UnpackOptions = 64,
 895   BuiltinOptions_FloorDivOptions = 65,
 896   BuiltinOptions_SquareOptions = 66,
 897   BuiltinOptions_ZerosLikeOptions = 67,
 898   BuiltinOptions_FillOptions = 68,
 899   BuiltinOptions_BidirectionalSequenceLSTMOptions = 69,
 900   BuiltinOptions_BidirectionalSequenceRNNOptions = 70,
 901   BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71,
 902   BuiltinOptions_FloorModOptions = 72,
 903   BuiltinOptions_RangeOptions = 73,
 904   BuiltinOptions_ResizeNearestNeighborOptions = 74,
 905   BuiltinOptions_LeakyReluOptions = 75,
 906   BuiltinOptions_SquaredDifferenceOptions = 76,
 907   BuiltinOptions_MirrorPadOptions = 77,
 908   BuiltinOptions_AbsOptions = 78,
 909   BuiltinOptions_SplitVOptions = 79,
 910   BuiltinOptions_UniqueOptions = 80,
 911   BuiltinOptions_ReverseV2Options = 81,
 912   BuiltinOptions_AddNOptions = 82,
 913   BuiltinOptions_GatherNdOptions = 83,
 914   BuiltinOptions_CosOptions = 84,
 915   BuiltinOptions_WhereOptions = 85,
 916   BuiltinOptions_RankOptions = 86,
 917   BuiltinOptions_ReverseSequenceOptions = 87,
 918   BuiltinOptions_MatrixDiagOptions = 88,
 919   BuiltinOptions_QuantizeOptions = 89,
 920   BuiltinOptions_MatrixSetDiagOptions = 90,
 921   BuiltinOptions_HardSwishOptions = 91,
 922   BuiltinOptions_IfOptions = 92,
 923   BuiltinOptions_WhileOptions = 93,
 924   BuiltinOptions_DepthToSpaceOptions = 94,
 925   BuiltinOptions_NonMaxSuppressionV4Options = 95,
 926   BuiltinOptions_NonMaxSuppressionV5Options = 96,
 927   BuiltinOptions_ScatterNdOptions = 97,
 928   BuiltinOptions_SelectV2Options = 98,
 929   BuiltinOptions_DensifyOptions = 99,
 930   BuiltinOptions_SegmentSumOptions = 100,
 931   BuiltinOptions_BatchMatMulOptions = 101,
 932   BuiltinOptions_MIN = BuiltinOptions_NONE,
 933   BuiltinOptions_MAX = BuiltinOptions_BatchMatMulOptions
 934 };
 935
 936 inline const BuiltinOptions (&EnumValuesBuiltinOptions())[102]
 937 {
 938   static const BuiltinOptions values[] = {BuiltinOptions_NONE,
 939                                           BuiltinOptions_Conv2DOptions,
 940                                           BuiltinOptions_DepthwiseConv2DOptions,
 941                                           BuiltinOptions_ConcatEmbeddingsOptions,
 942                                           BuiltinOptions_LSHProjectionOptions,
 943                                           BuiltinOptions_Pool2DOptions,
 944                                           BuiltinOptions_SVDFOptions,
 945                                           BuiltinOptions_RNNOptions,
 946                                           BuiltinOptions_FullyConnectedOptions,
 947                                           BuiltinOptions_SoftmaxOptions,
 948                                           BuiltinOptions_ConcatenationOptions,
 949                                           BuiltinOptions_AddOptions,
 950                                           BuiltinOptions_L2NormOptions,
 951                                           BuiltinOptions_LocalResponseNormalizationOptions,
 952                                           BuiltinOptions_LSTMOptions,
 953                                           BuiltinOptions_ResizeBilinearOptions,
 954                                           BuiltinOptions_CallOptions,
 955                                           BuiltinOptions_ReshapeOptions,
 956                                           BuiltinOptions_SkipGramOptions,
 957                                           BuiltinOptions_SpaceToDepthOptions,
 958                                           BuiltinOptions_EmbeddingLookupSparseOptions,
 959                                           BuiltinOptions_MulOptions,
 960                                           BuiltinOptions_PadOptions,
 961                                           BuiltinOptions_GatherOptions,
 962                                           BuiltinOptions_BatchToSpaceNDOptions,
 963                                           BuiltinOptions_SpaceToBatchNDOptions,
 964                                           BuiltinOptions_TransposeOptions,
 965                                           BuiltinOptions_ReducerOptions,
 966                                           BuiltinOptions_SubOptions,
 967                                           BuiltinOptions_DivOptions,
 968                                           BuiltinOptions_SqueezeOptions,
 969                                           BuiltinOptions_SequenceRNNOptions,
 970                                           BuiltinOptions_StridedSliceOptions,
 971                                           BuiltinOptions_ExpOptions,
 972                                           BuiltinOptions_TopKV2Options,
 973                                           BuiltinOptions_SplitOptions,
 974                                           BuiltinOptions_LogSoftmaxOptions,
 975                                           BuiltinOptions_CastOptions,
 976                                           BuiltinOptions_DequantizeOptions,
 977                                           BuiltinOptions_MaximumMinimumOptions,
 978                                           BuiltinOptions_ArgMaxOptions,
 979                                           BuiltinOptions_LessOptions,
 980                                           BuiltinOptions_NegOptions,
 981                                           BuiltinOptions_PadV2Options,
 982                                           BuiltinOptions_GreaterOptions,
 983                                           BuiltinOptions_GreaterEqualOptions,
 984                                           BuiltinOptions_LessEqualOptions,
 985                                           BuiltinOptions_SelectOptions,
 986                                           BuiltinOptions_SliceOptions,
 987                                           BuiltinOptions_TransposeConvOptions,
 988                                           BuiltinOptions_SparseToDenseOptions,
 989                                           BuiltinOptions_TileOptions,
 990                                           BuiltinOptions_ExpandDimsOptions,
 991                                           BuiltinOptions_EqualOptions,
 992                                           BuiltinOptions_NotEqualOptions,
 993                                           BuiltinOptions_ShapeOptions,
 994                                           BuiltinOptions_PowOptions,
 995                                           BuiltinOptions_ArgMinOptions,
 996                                           BuiltinOptions_FakeQuantOptions,
 997                                           BuiltinOptions_PackOptions,
 998                                           BuiltinOptions_LogicalOrOptions,
 999                                           BuiltinOptions_OneHotOptions,
1000                                           BuiltinOptions_LogicalAndOptions,
1001                                           BuiltinOptions_LogicalNotOptions,
1002                                           BuiltinOptions_UnpackOptions,
1003                                           BuiltinOptions_FloorDivOptions,
1004                                           BuiltinOptions_SquareOptions,
1005                                           BuiltinOptions_ZerosLikeOptions,
1006                                           BuiltinOptions_FillOptions,
1007                                           BuiltinOptions_BidirectionalSequenceLSTMOptions,
1008                                           BuiltinOptions_BidirectionalSequenceRNNOptions,
1009                                           BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1010                                           BuiltinOptions_FloorModOptions,
1011                                           BuiltinOptions_RangeOptions,
1012                                           BuiltinOptions_ResizeNearestNeighborOptions,
1013                                           BuiltinOptions_LeakyReluOptions,
1014                                           BuiltinOptions_SquaredDifferenceOptions,
1015                                           BuiltinOptions_MirrorPadOptions,
1016                                           BuiltinOptions_AbsOptions,
1017                                           BuiltinOptions_SplitVOptions,
1018                                           BuiltinOptions_UniqueOptions,
1019                                           BuiltinOptions_ReverseV2Options,
1020                                           BuiltinOptions_AddNOptions,
1021                                           BuiltinOptions_GatherNdOptions,
1022                                           BuiltinOptions_CosOptions,
1023                                           BuiltinOptions_WhereOptions,
1024                                           BuiltinOptions_RankOptions,
1025                                           BuiltinOptions_ReverseSequenceOptions,
1026                                           BuiltinOptions_MatrixDiagOptions,
1027                                           BuiltinOptions_QuantizeOptions,
1028                                           BuiltinOptions_MatrixSetDiagOptions,
1029                                           BuiltinOptions_HardSwishOptions,
1030                                           BuiltinOptions_IfOptions,
1031                                           BuiltinOptions_WhileOptions,
1032                                           BuiltinOptions_DepthToSpaceOptions,
1033                                           BuiltinOptions_NonMaxSuppressionV4Options,
1034                                           BuiltinOptions_NonMaxSuppressionV5Options,
1035                                           BuiltinOptions_ScatterNdOptions,
1036                                           BuiltinOptions_SelectV2Options,
1037                                           BuiltinOptions_DensifyOptions,
1038                                           BuiltinOptions_SegmentSumOptions,
1039                                           BuiltinOptions_BatchMatMulOptions};
1040   return values;
1041 }
1042
1043 inline const char *const *EnumNamesBuiltinOptions()
1044 {
1045   static const char *const names[] = {"NONE",
1046                                       "Conv2DOptions",
1047                                       "DepthwiseConv2DOptions",
1048                                       "ConcatEmbeddingsOptions",
1049                                       "LSHProjectionOptions",
1050                                       "Pool2DOptions",
1051                                       "SVDFOptions",
1052                                       "RNNOptions",
1053                                       "FullyConnectedOptions",
1054                                       "SoftmaxOptions",
1055                                       "ConcatenationOptions",
1056                                       "AddOptions",
1057                                       "L2NormOptions",
1058                                       "LocalResponseNormalizationOptions",
1059                                       "LSTMOptions",
1060                                       "ResizeBilinearOptions",
1061                                       "CallOptions",
1062                                       "ReshapeOptions",
1063                                       "SkipGramOptions",
1064                                       "SpaceToDepthOptions",
1065                                       "EmbeddingLookupSparseOptions",
1066                                       "MulOptions",
1067                                       "PadOptions",
1068                                       "GatherOptions",
1069                                       "BatchToSpaceNDOptions",
1070                                       "SpaceToBatchNDOptions",
1071                                       "TransposeOptions",
1072                                       "ReducerOptions",
1073                                       "SubOptions",
1074                                       "DivOptions",
1075                                       "SqueezeOptions",
1076                                       "SequenceRNNOptions",
1077                                       "StridedSliceOptions",
1078                                       "ExpOptions",
1079                                       "TopKV2Options",
1080                                       "SplitOptions",
1081                                       "LogSoftmaxOptions",
1082                                       "CastOptions",
1083                                       "DequantizeOptions",
1084                                       "MaximumMinimumOptions",
1085                                       "ArgMaxOptions",
1086                                       "LessOptions",
1087                                       "NegOptions",
1088                                       "PadV2Options",
1089                                       "GreaterOptions",
1090                                       "GreaterEqualOptions",
1091                                       "LessEqualOptions",
1092                                       "SelectOptions",
1093                                       "SliceOptions",
1094                                       "TransposeConvOptions",
1095                                       "SparseToDenseOptions",
1096                                       "TileOptions",
1097                                       "ExpandDimsOptions",
1098                                       "EqualOptions",
1099                                       "NotEqualOptions",
1100                                       "ShapeOptions",
1101                                       "PowOptions",
1102                                       "ArgMinOptions",
1103                                       "FakeQuantOptions",
1104                                       "PackOptions",
1105                                       "LogicalOrOptions",
1106                                       "OneHotOptions",
1107                                       "LogicalAndOptions",
1108                                       "LogicalNotOptions",
1109                                       "UnpackOptions",
1110                                       "FloorDivOptions",
1111                                       "SquareOptions",
1112                                       "ZerosLikeOptions",
1113                                       "FillOptions",
1114                                       "BidirectionalSequenceLSTMOptions",
1115                                       "BidirectionalSequenceRNNOptions",
1116                                       "UnidirectionalSequenceLSTMOptions",
1117                                       "FloorModOptions",
1118                                       "RangeOptions",
1119                                       "ResizeNearestNeighborOptions",
1120                                       "LeakyReluOptions",
1121                                       "SquaredDifferenceOptions",
1122                                       "MirrorPadOptions",
1123                                       "AbsOptions",
1124                                       "SplitVOptions",
1125                                       "UniqueOptions",
1126                                       "ReverseV2Options",
1127                                       "AddNOptions",
1128                                       "GatherNdOptions",
1129                                       "CosOptions",
1130                                       "WhereOptions",
1131                                       "RankOptions",
1132                                       "ReverseSequenceOptions",
1133                                       "MatrixDiagOptions",
1134                                       "QuantizeOptions",
1135                                       "MatrixSetDiagOptions",
1136                                       "HardSwishOptions",
1137                                       "IfOptions",
1138                                       "WhileOptions",
1139                                       "DepthToSpaceOptions",
1140                                       "NonMaxSuppressionV4Options",
1141                                       "NonMaxSuppressionV5Options",
1142                                       "ScatterNdOptions",
1143                                       "SelectV2Options",
1144                                       "DensifyOptions",
1145                                       "SegmentSumOptions",
1146                                       "BatchMatMulOptions",
1147                                       nullptr};
1148   return names;
1149 }
1150
1151 inline const char *EnumNameBuiltinOptions(BuiltinOptions e)
1152 {
1153   const size_t index = static_cast<int>(e);
1154   return EnumNamesBuiltinOptions()[index];
1155 }
1156
1157 template <typename T> struct BuiltinOptionsTraits
1158 {
1159   static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1160 };
1161
1162 template <> struct BuiltinOptionsTraits<Conv2DOptions>
1163 {
1164   static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1165 };
1166
1167 template <> struct BuiltinOptionsTraits<DepthwiseConv2DOptions>
1168 {
1169   static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1170 };
1171
1172 template <> struct BuiltinOptionsTraits<ConcatEmbeddingsOptions>
1173 {
1174   static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1175 };
1176
1177 template <> struct BuiltinOptionsTraits<LSHProjectionOptions>
1178 {
1179   static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1180 };
1181
1182 template <> struct BuiltinOptionsTraits<Pool2DOptions>
1183 {
1184   static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1185 };
1186
1187 template <> struct BuiltinOptionsTraits<SVDFOptions>
1188 {
1189   static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1190 };
1191
1192 template <> struct BuiltinOptionsTraits<RNNOptions>
1193 {
1194   static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1195 };
1196
1197 template <> struct BuiltinOptionsTraits<FullyConnectedOptions>
1198 {
1199   static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1200 };
1201
1202 template <> struct BuiltinOptionsTraits<SoftmaxOptions>
1203 {
1204   static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1205 };
1206
1207 template <> struct BuiltinOptionsTraits<ConcatenationOptions>
1208 {
1209   static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1210 };
1211
1212 template <> struct BuiltinOptionsTraits<AddOptions>
1213 {
1214   static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1215 };
1216
1217 template <> struct BuiltinOptionsTraits<L2NormOptions>
1218 {
1219   static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1220 };
1221
1222 template <> struct BuiltinOptionsTraits<LocalResponseNormalizationOptions>
1223 {
1224   static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1225 };
1226
1227 template <> struct BuiltinOptionsTraits<LSTMOptions>
1228 {
1229   static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1230 };
1231
1232 template <> struct BuiltinOptionsTraits<ResizeBilinearOptions>
1233 {
1234   static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1235 };
1236
1237 template <> struct BuiltinOptionsTraits<CallOptions>
1238 {
1239   static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1240 };
1241
1242 template <> struct BuiltinOptionsTraits<ReshapeOptions>
1243 {
1244   static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1245 };
1246
1247 template <> struct BuiltinOptionsTraits<SkipGramOptions>
1248 {
1249   static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1250 };
1251
1252 template <> struct BuiltinOptionsTraits<SpaceToDepthOptions>
1253 {
1254   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1255 };
1256
1257 template <> struct BuiltinOptionsTraits<EmbeddingLookupSparseOptions>
1258 {
1259   static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1260 };
1261
1262 template <> struct BuiltinOptionsTraits<MulOptions>
1263 {
1264   static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1265 };
1266
1267 template <> struct BuiltinOptionsTraits<PadOptions>
1268 {
1269   static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1270 };
1271
1272 template <> struct BuiltinOptionsTraits<GatherOptions>
1273 {
1274   static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1275 };
1276
1277 template <> struct BuiltinOptionsTraits<BatchToSpaceNDOptions>
1278 {
1279   static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
1280 };
1281
1282 template <> struct BuiltinOptionsTraits<SpaceToBatchNDOptions>
1283 {
1284   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
1285 };
1286
1287 template <> struct BuiltinOptionsTraits<TransposeOptions>
1288 {
1289   static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
1290 };
1291
1292 template <> struct BuiltinOptionsTraits<ReducerOptions>
1293 {
1294   static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
1295 };
1296
1297 template <> struct BuiltinOptionsTraits<SubOptions>
1298 {
1299   static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
1300 };
1301
1302 template <> struct BuiltinOptionsTraits<DivOptions>
1303 {
1304   static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
1305 };
1306
1307 template <> struct BuiltinOptionsTraits<SqueezeOptions>
1308 {
1309   static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
1310 };
1311
1312 template <> struct BuiltinOptionsTraits<SequenceRNNOptions>
1313 {
1314   static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
1315 };
1316
1317 template <> struct BuiltinOptionsTraits<StridedSliceOptions>
1318 {
1319   static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
1320 };
1321
1322 template <> struct BuiltinOptionsTraits<ExpOptions>
1323 {
1324   static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
1325 };
1326
1327 template <> struct BuiltinOptionsTraits<TopKV2Options>
1328 {
1329   static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
1330 };
1331
1332 template <> struct BuiltinOptionsTraits<SplitOptions>
1333 {
1334   static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
1335 };
1336
1337 template <> struct BuiltinOptionsTraits<LogSoftmaxOptions>
1338 {
1339   static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
1340 };
1341
1342 template <> struct BuiltinOptionsTraits<CastOptions>
1343 {
1344   static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
1345 };
1346
1347 template <> struct BuiltinOptionsTraits<DequantizeOptions>
1348 {
1349   static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
1350 };
1351
1352 template <> struct BuiltinOptionsTraits<MaximumMinimumOptions>
1353 {
1354   static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
1355 };
1356
1357 template <> struct BuiltinOptionsTraits<ArgMaxOptions>
1358 {
1359   static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
1360 };
1361
1362 template <> struct BuiltinOptionsTraits<LessOptions>
1363 {
1364   static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
1365 };
1366
1367 template <> struct BuiltinOptionsTraits<NegOptions>
1368 {
1369   static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
1370 };
1371
1372 template <> struct BuiltinOptionsTraits<PadV2Options>
1373 {
1374   static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
1375 };
1376
1377 template <> struct BuiltinOptionsTraits<GreaterOptions>
1378 {
1379   static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
1380 };
1381
1382 template <> struct BuiltinOptionsTraits<GreaterEqualOptions>
1383 {
1384   static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
1385 };
1386
1387 template <> struct BuiltinOptionsTraits<LessEqualOptions>
1388 {
1389   static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
1390 };
1391
1392 template <> struct BuiltinOptionsTraits<SelectOptions>
1393 {
1394   static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
1395 };
1396
1397 template <> struct BuiltinOptionsTraits<SliceOptions>
1398 {
1399   static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
1400 };
1401
1402 template <> struct BuiltinOptionsTraits<TransposeConvOptions>
1403 {
1404   static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
1405 };
1406
1407 template <> struct BuiltinOptionsTraits<SparseToDenseOptions>
1408 {
1409   static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
1410 };
1411
1412 template <> struct BuiltinOptionsTraits<TileOptions>
1413 {
1414   static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
1415 };
1416
1417 template <> struct BuiltinOptionsTraits<ExpandDimsOptions>
1418 {
1419   static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
1420 };
1421
1422 template <> struct BuiltinOptionsTraits<EqualOptions>
1423 {
1424   static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
1425 };
1426
1427 template <> struct BuiltinOptionsTraits<NotEqualOptions>
1428 {
1429   static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
1430 };
1431
1432 template <> struct BuiltinOptionsTraits<ShapeOptions>
1433 {
1434   static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
1435 };
1436
1437 template <> struct BuiltinOptionsTraits<PowOptions>
1438 {
1439   static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
1440 };
1441
1442 template <> struct BuiltinOptionsTraits<ArgMinOptions>
1443 {
1444   static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
1445 };
1446
1447 template <> struct BuiltinOptionsTraits<FakeQuantOptions>
1448 {
1449   static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
1450 };
1451
1452 template <> struct BuiltinOptionsTraits<PackOptions>
1453 {
1454   static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
1455 };
1456
1457 template <> struct BuiltinOptionsTraits<LogicalOrOptions>
1458 {
1459   static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
1460 };
1461
1462 template <> struct BuiltinOptionsTraits<OneHotOptions>
1463 {
1464   static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
1465 };
1466
1467 template <> struct BuiltinOptionsTraits<LogicalAndOptions>
1468 {
1469   static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
1470 };
1471
1472 template <> struct BuiltinOptionsTraits<LogicalNotOptions>
1473 {
1474   static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
1475 };
1476
1477 template <> struct BuiltinOptionsTraits<UnpackOptions>
1478 {
1479   static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
1480 };
1481
1482 template <> struct BuiltinOptionsTraits<FloorDivOptions>
1483 {
1484   static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
1485 };
1486
1487 template <> struct BuiltinOptionsTraits<SquareOptions>
1488 {
1489   static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
1490 };
1491
1492 template <> struct BuiltinOptionsTraits<ZerosLikeOptions>
1493 {
1494   static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
1495 };
1496
1497 template <> struct BuiltinOptionsTraits<FillOptions>
1498 {
1499   static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
1500 };
1501
1502 template <> struct BuiltinOptionsTraits<BidirectionalSequenceLSTMOptions>
1503 {
1504   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
1505 };
1506
1507 template <> struct BuiltinOptionsTraits<BidirectionalSequenceRNNOptions>
1508 {
1509   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
1510 };
1511
1512 template <> struct BuiltinOptionsTraits<UnidirectionalSequenceLSTMOptions>
1513 {
1514   static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
1515 };
1516
1517 template <> struct BuiltinOptionsTraits<FloorModOptions>
1518 {
1519   static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
1520 };
1521
1522 template <> struct BuiltinOptionsTraits<RangeOptions>
1523 {
1524   static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
1525 };
1526
1527 template <> struct BuiltinOptionsTraits<ResizeNearestNeighborOptions>
1528 {
1529   static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
1530 };
1531
1532 template <> struct BuiltinOptionsTraits<LeakyReluOptions>
1533 {
1534   static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
1535 };
1536
1537 template <> struct BuiltinOptionsTraits<SquaredDifferenceOptions>
1538 {
1539   static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
1540 };
1541
1542 template <> struct BuiltinOptionsTraits<MirrorPadOptions>
1543 {
1544   static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
1545 };
1546
1547 template <> struct BuiltinOptionsTraits<AbsOptions>
1548 {
1549   static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
1550 };
1551
1552 template <> struct BuiltinOptionsTraits<SplitVOptions>
1553 {
1554   static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
1555 };
1556
1557 template <> struct BuiltinOptionsTraits<UniqueOptions>
1558 {
1559   static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
1560 };
1561
1562 template <> struct BuiltinOptionsTraits<ReverseV2Options>
1563 {
1564   static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
1565 };
1566
1567 template <> struct BuiltinOptionsTraits<AddNOptions>
1568 {
1569   static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
1570 };
1571
1572 template <> struct BuiltinOptionsTraits<GatherNdOptions>
1573 {
1574   static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
1575 };
1576
1577 template <> struct BuiltinOptionsTraits<CosOptions>
1578 {
1579   static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
1580 };
1581
1582 template <> struct BuiltinOptionsTraits<WhereOptions>
1583 {
1584   static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
1585 };
1586
1587 template <> struct BuiltinOptionsTraits<RankOptions>
1588 {
1589   static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
1590 };
1591
1592 template <> struct BuiltinOptionsTraits<ReverseSequenceOptions>
1593 {
1594   static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
1595 };
1596
1597 template <> struct BuiltinOptionsTraits<MatrixDiagOptions>
1598 {
1599   static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
1600 };
1601
1602 template <> struct BuiltinOptionsTraits<QuantizeOptions>
1603 {
1604   static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
1605 };
1606
1607 template <> struct BuiltinOptionsTraits<MatrixSetDiagOptions>
1608 {
1609   static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
1610 };
1611
1612 template <> struct BuiltinOptionsTraits<HardSwishOptions>
1613 {
1614   static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
1615 };
1616
1617 template <> struct BuiltinOptionsTraits<IfOptions>
1618 {
1619   static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
1620 };
1621
1622 template <> struct BuiltinOptionsTraits<WhileOptions>
1623 {
1624   static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
1625 };
1626
1627 template <> struct BuiltinOptionsTraits<DepthToSpaceOptions>
1628 {
1629   static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
1630 };
1631
1632 template <> struct BuiltinOptionsTraits<NonMaxSuppressionV4Options>
1633 {
1634   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
1635 };
1636
1637 template <> struct BuiltinOptionsTraits<NonMaxSuppressionV5Options>
1638 {
1639   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
1640 };
1641
1642 template <> struct BuiltinOptionsTraits<ScatterNdOptions>
1643 {
1644   static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
1645 };
1646
1647 template <> struct BuiltinOptionsTraits<SelectV2Options>
1648 {
1649   static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
1650 };
1651
1652 template <> struct BuiltinOptionsTraits<DensifyOptions>
1653 {
1654   static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
1655 };
1656
1657 template <> struct BuiltinOptionsTraits<SegmentSumOptions>
1658 {
1659   static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
1660 };
1661
1662 template <> struct BuiltinOptionsTraits<BatchMatMulOptions>
1663 {
1664   static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
1665 };
1666
1667 bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
1668 bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
1669                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
1670                                 const flatbuffers::Vector<uint8_t> *types);
1671
1672 enum Padding
1673 {
1674   Padding_SAME = 0,
1675   Padding_VALID = 1,
1676   Padding_MIN = Padding_SAME,
1677   Padding_MAX = Padding_VALID
1678 };
1679
1680 inline const Padding (&EnumValuesPadding())[2]
1681 {
1682   static const Padding values[] = {Padding_SAME, Padding_VALID};
1683   return values;
1684 }
1685
1686 inline const char *const *EnumNamesPadding()
1687 {
1688   static const char *const names[] = {"SAME", "VALID", nullptr};
1689   return names;
1690 }
1691
1692 inline const char *EnumNamePadding(Padding e)
1693 {
1694   const size_t index = static_cast<int>(e);
1695   return EnumNamesPadding()[index];
1696 }
1697
1698 enum ActivationFunctionType
1699 {
1700   ActivationFunctionType_NONE = 0,
1701   ActivationFunctionType_RELU = 1,
1702   ActivationFunctionType_RELU_N1_TO_1 = 2,
1703   ActivationFunctionType_RELU6 = 3,
1704   ActivationFunctionType_TANH = 4,
1705   ActivationFunctionType_SIGN_BIT = 5,
1706   ActivationFunctionType_MIN = ActivationFunctionType_NONE,
1707   ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
1708 };
1709
1710 inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6]
1711 {
1712   static const ActivationFunctionType values[] = {
1713       ActivationFunctionType_NONE,         ActivationFunctionType_RELU,
1714       ActivationFunctionType_RELU_N1_TO_1, ActivationFunctionType_RELU6,
1715       ActivationFunctionType_TANH,         ActivationFunctionType_SIGN_BIT};
1716   return values;
1717 }
1718
1719 inline const char *const *EnumNamesActivationFunctionType()
1720 {
1721   static const char *const names[] = {"NONE", "RELU",     "RELU_N1_TO_1", "RELU6",
1722                                       "TANH", "SIGN_BIT", nullptr};
1723   return names;
1724 }
1725
1726 inline const char *EnumNameActivationFunctionType(ActivationFunctionType e)
1727 {
1728   const size_t index = static_cast<int>(e);
1729   return EnumNamesActivationFunctionType()[index];
1730 }
1731
1732 enum LSHProjectionType
1733 {
1734   LSHProjectionType_UNKNOWN = 0,
1735   LSHProjectionType_SPARSE = 1,
1736   LSHProjectionType_DENSE = 2,
1737   LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
1738   LSHProjectionType_MAX = LSHProjectionType_DENSE
1739 };
1740
1741 inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3]
1742 {
1743   static const LSHProjectionType values[] = {LSHProjectionType_UNKNOWN, LSHProjectionType_SPARSE,
1744                                              LSHProjectionType_DENSE};
1745   return values;
1746 }
1747
1748 inline const char *const *EnumNamesLSHProjectionType()
1749 {
1750   static const char *const names[] = {"UNKNOWN", "SPARSE", "DENSE", nullptr};
1751   return names;
1752 }
1753
1754 inline const char *EnumNameLSHProjectionType(LSHProjectionType e)
1755 {
1756   const size_t index = static_cast<int>(e);
1757   return EnumNamesLSHProjectionType()[index];
1758 }
1759
1760 enum FullyConnectedOptionsWeightsFormat
1761 {
1762   FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
1763   FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
1764   FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
1765   FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
1766 };
1767
1768 inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2]
1769 {
1770   static const FullyConnectedOptionsWeightsFormat values[] = {
1771       FullyConnectedOptionsWeightsFormat_DEFAULT,
1772       FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8};
1773   return values;
1774 }
1775
1776 inline const char *const *EnumNamesFullyConnectedOptionsWeightsFormat()
1777 {
1778   static const char *const names[] = {"DEFAULT", "SHUFFLED4x16INT8", nullptr};
1779   return names;
1780 }
1781
1782 inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e)
1783 {
1784   const size_t index = static_cast<int>(e);
1785   return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
1786 }
1787
1788 enum LSTMKernelType
1789 {
1790   LSTMKernelType_FULL = 0,
1791   LSTMKernelType_BASIC = 1,
1792   LSTMKernelType_MIN = LSTMKernelType_FULL,
1793   LSTMKernelType_MAX = LSTMKernelType_BASIC
1794 };
1795
1796 inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2]
1797 {
1798   static const LSTMKernelType values[] = {LSTMKernelType_FULL, LSTMKernelType_BASIC};
1799   return values;
1800 }
1801
1802 inline const char *const *EnumNamesLSTMKernelType()
1803 {
1804   static const char *const names[] = {"FULL", "BASIC", nullptr};
1805   return names;
1806 }
1807
1808 inline const char *EnumNameLSTMKernelType(LSTMKernelType e)
1809 {
1810   const size_t index = static_cast<int>(e);
1811   return EnumNamesLSTMKernelType()[index];
1812 }
1813
1814 enum CombinerType
1815 {
1816   CombinerType_SUM = 0,
1817   CombinerType_MEAN = 1,
1818   CombinerType_SQRTN = 2,
1819   CombinerType_MIN = CombinerType_SUM,
1820   CombinerType_MAX = CombinerType_SQRTN
1821 };
1822
1823 inline const CombinerType (&EnumValuesCombinerType())[3]
1824 {
1825   static const CombinerType values[] = {CombinerType_SUM, CombinerType_MEAN, CombinerType_SQRTN};
1826   return values;
1827 }
1828
1829 inline const char *const *EnumNamesCombinerType()
1830 {
1831   static const char *const names[] = {"SUM", "MEAN", "SQRTN", nullptr};
1832   return names;
1833 }
1834
1835 inline const char *EnumNameCombinerType(CombinerType e)
1836 {
1837   const size_t index = static_cast<int>(e);
1838   return EnumNamesCombinerType()[index];
1839 }
1840
1841 enum MirrorPadMode
1842 {
1843   MirrorPadMode_REFLECT = 0,
1844   MirrorPadMode_SYMMETRIC = 1,
1845   MirrorPadMode_MIN = MirrorPadMode_REFLECT,
1846   MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
1847 };
1848
1849 inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2]
1850 {
1851   static const MirrorPadMode values[] = {MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC};
1852   return values;
1853 }
1854
1855 inline const char *const *EnumNamesMirrorPadMode()
1856 {
1857   static const char *const names[] = {"REFLECT", "SYMMETRIC", nullptr};
1858   return names;
1859 }
1860
1861 inline const char *EnumNameMirrorPadMode(MirrorPadMode e)
1862 {
1863   const size_t index = static_cast<int>(e);
1864   return EnumNamesMirrorPadMode()[index];
1865 }
1866
1867 enum CustomOptionsFormat
1868 {
1869   CustomOptionsFormat_FLEXBUFFERS = 0,
1870   CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
1871   CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
1872 };
1873
1874 inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1]
1875 {
1876   static const CustomOptionsFormat values[] = {CustomOptionsFormat_FLEXBUFFERS};
1877   return values;
1878 }
1879
1880 inline const char *const *EnumNamesCustomOptionsFormat()
1881 {
1882   static const char *const names[] = {"FLEXBUFFERS", nullptr};
1883   return names;
1884 }
1885
1886 inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e)
1887 {
1888   const size_t index = static_cast<int>(e);
1889   return EnumNamesCustomOptionsFormat()[index];
1890 }
1891
1892 struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
1893 {
1894   enum
1895   {
1896     VT_CUSTOM = 4
1897   };
1898   const flatbuffers::Vector<uint8_t> *custom() const
1899   {
1900     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
1901   }
1902   bool Verify(flatbuffers::Verifier &verifier) const
1903   {
1904     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CUSTOM) &&
1905            verifier.VerifyVector(custom()) && verifier.EndTable();
1906   }
1907 };
1908
1909 struct CustomQuantizationBuilder
1910 {
1911   flatbuffers::FlatBufferBuilder &fbb_;
1912   flatbuffers::uoffset_t start_;
1913   void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom)
1914   {
1915     fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
1916   }
1917   explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
1918   {
1919     start_ = fbb_.StartTable();
1920   }
1921   CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &);
1922   flatbuffers::Offset<CustomQuantization> Finish()
1923   {
1924     const auto end = fbb_.EndTable(start_);
1925     auto o = flatbuffers::Offset<CustomQuantization>(end);
1926     return o;
1927   }
1928 };
1929
1930 inline flatbuffers::Offset<CustomQuantization>
1931 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb,
1932                          flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0)
1933 {
1934   CustomQuantizationBuilder builder_(_fbb);
1935   builder_.add_custom(custom);
1936   return builder_.Finish();
1937 }
1938
1939 inline flatbuffers::Offset<CustomQuantization>
1940 CreateCustomQuantizationDirect(flatbuffers::FlatBufferBuilder &_fbb,
1941                                const std::vector<uint8_t> *custom = nullptr)
1942 {
1943   return onert_tflite::CreateCustomQuantization(_fbb,
1944                                                 custom ? _fbb.CreateVector<uint8_t>(*custom) : 0);
1945 }
1946
1947 struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
1948 {
1949   enum
1950   {
1951     VT_MIN = 4,
1952     VT_MAX = 6,
1953     VT_SCALE = 8,
1954     VT_ZERO_POINT = 10,
1955     VT_DETAILS_TYPE = 12,
1956     VT_DETAILS = 14,
1957     VT_QUANTIZED_DIMENSION = 16
1958   };
1959   const flatbuffers::Vector<float> *min() const
1960   {
1961     return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
1962   }
1963   const flatbuffers::Vector<float> *max() const
1964   {
1965     return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
1966   }
1967   const flatbuffers::Vector<float> *scale() const
1968   {
1969     return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
1970   }
1971   const flatbuffers::Vector<int64_t> *zero_point() const
1972   {
1973     return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
1974   }
1975   QuantizationDetails details_type() const
1976   {
1977     return static_cast<QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
1978   }
1979   const void *details() const { return GetPointer<const void *>(VT_DETAILS); }
1980   template <typename T> const T *details_as() const;
1981   const CustomQuantization *details_as_CustomQuantization() const
1982   {
1983     return details_type() == QuantizationDetails_CustomQuantization
1984                ? static_cast<const CustomQuantization *>(details())
1985                : nullptr;
1986   }
1987   int32_t quantized_dimension() const { return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0); }
1988   bool Verify(flatbuffers::Verifier &verifier) const
1989   {
1990     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) &&
1991            verifier.VerifyVector(min()) && VerifyOffset(verifier, VT_MAX) &&
1992            verifier.VerifyVector(max()) && VerifyOffset(verifier, VT_SCALE) &&
1993            verifier.VerifyVector(scale()) && VerifyOffset(verifier, VT_ZERO_POINT) &&
1994            verifier.VerifyVector(zero_point()) && VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
1995            VerifyOffset(verifier, VT_DETAILS) &&
1996            VerifyQuantizationDetails(verifier, details(), details_type()) &&
1997            VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) && verifier.EndTable();
1998   }
1999 };
2000
2001 template <>
2002 inline const CustomQuantization *QuantizationParameters::details_as<CustomQuantization>() const
2003 {
2004   return details_as_CustomQuantization();
2005 }
2006
2007 struct QuantizationParametersBuilder
2008 {
2009   flatbuffers::FlatBufferBuilder &fbb_;
2010   flatbuffers::uoffset_t start_;
2011   void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min)
2012   {
2013     fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
2014   }
2015   void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max)
2016   {
2017     fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
2018   }
2019   void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale)
2020   {
2021     fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
2022   }
2023   void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point)
2024   {
2025     fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
2026   }
2027   void add_details_type(QuantizationDetails details_type)
2028   {
2029     fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE,
2030                              static_cast<uint8_t>(details_type), 0);
2031   }
2032   void add_details(flatbuffers::Offset<void> details)
2033   {
2034     fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
2035   }
2036   void add_quantized_dimension(int32_t quantized_dimension)
2037   {
2038     fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension,
2039                              0);
2040   }
2041   explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2042   {
2043     start_ = fbb_.StartTable();
2044   }
2045   QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
2046   flatbuffers::Offset<QuantizationParameters> Finish()
2047   {
2048     const auto end = fbb_.EndTable(start_);
2049     auto o = flatbuffers::Offset<QuantizationParameters>(end);
2050     return o;
2051   }
2052 };
2053
2054 inline flatbuffers::Offset<QuantizationParameters>
2055 CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb,
2056                              flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
2057                              flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
2058                              flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
2059                              flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
2060                              QuantizationDetails details_type = QuantizationDetails_NONE,
2061                              flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2062 {
2063   QuantizationParametersBuilder builder_(_fbb);
2064   builder_.add_quantized_dimension(quantized_dimension);
2065   builder_.add_details(details);
2066   builder_.add_zero_point(zero_point);
2067   builder_.add_scale(scale);
2068   builder_.add_max(max);
2069   builder_.add_min(min);
2070   builder_.add_details_type(details_type);
2071   return builder_.Finish();
2072 }
2073
2074 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
2075     flatbuffers::FlatBufferBuilder &_fbb, const std::vector<float> *min = nullptr,
2076     const std::vector<float> *max = nullptr, const std::vector<float> *scale = nullptr,
2077     const std::vector<int64_t> *zero_point = nullptr,
2078     QuantizationDetails details_type = QuantizationDetails_NONE,
2079     flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2080 {
2081   return onert_tflite::CreateQuantizationParameters(
2082       _fbb, min ? _fbb.CreateVector<float>(*min) : 0, max ? _fbb.CreateVector<float>(*max) : 0,
2083       scale ? _fbb.CreateVector<float>(*scale) : 0,
2084       zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0, details_type, details,
2085       quantized_dimension);
2086 }
2087
2088 struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2089 {
2090   enum
2091   {
2092     VT_VALUES = 4
2093   };
2094   const flatbuffers::Vector<int32_t> *values() const
2095   {
2096     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
2097   }
2098   bool Verify(flatbuffers::Verifier &verifier) const
2099   {
2100     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2101            verifier.VerifyVector(values()) && verifier.EndTable();
2102   }
2103 };
2104
2105 struct Int32VectorBuilder
2106 {
2107   flatbuffers::FlatBufferBuilder &fbb_;
2108   flatbuffers::uoffset_t start_;
2109   void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values)
2110   {
2111     fbb_.AddOffset(Int32Vector::VT_VALUES, values);
2112   }
2113   explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2114   {
2115     start_ = fbb_.StartTable();
2116   }
2117   Int32VectorBuilder &operator=(const Int32VectorBuilder &);
2118   flatbuffers::Offset<Int32Vector> Finish()
2119   {
2120     const auto end = fbb_.EndTable(start_);
2121     auto o = flatbuffers::Offset<Int32Vector>(end);
2122     return o;
2123   }
2124 };
2125
2126 inline flatbuffers::Offset<Int32Vector>
2127 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb,
2128                   flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0)
2129 {
2130   Int32VectorBuilder builder_(_fbb);
2131   builder_.add_values(values);
2132   return builder_.Finish();
2133 }
2134
2135 inline flatbuffers::Offset<Int32Vector>
2136 CreateInt32VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2137                         const std::vector<int32_t> *values = nullptr)
2138 {
2139   return onert_tflite::CreateInt32Vector(_fbb, values ? _fbb.CreateVector<int32_t>(*values) : 0);
2140 }
2141
2142 struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2143 {
2144   enum
2145   {
2146     VT_VALUES = 4
2147   };
2148   const flatbuffers::Vector<uint16_t> *values() const
2149   {
2150     return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
2151   }
2152   bool Verify(flatbuffers::Verifier &verifier) const
2153   {
2154     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2155            verifier.VerifyVector(values()) && verifier.EndTable();
2156   }
2157 };
2158
2159 struct Uint16VectorBuilder
2160 {
2161   flatbuffers::FlatBufferBuilder &fbb_;
2162   flatbuffers::uoffset_t start_;
2163   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values)
2164   {
2165     fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
2166   }
2167   explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2168   {
2169     start_ = fbb_.StartTable();
2170   }
2171   Uint16VectorBuilder &operator=(const Uint16VectorBuilder &);
2172   flatbuffers::Offset<Uint16Vector> Finish()
2173   {
2174     const auto end = fbb_.EndTable(start_);
2175     auto o = flatbuffers::Offset<Uint16Vector>(end);
2176     return o;
2177   }
2178 };
2179
2180 inline flatbuffers::Offset<Uint16Vector>
2181 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb,
2182                    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0)
2183 {
2184   Uint16VectorBuilder builder_(_fbb);
2185   builder_.add_values(values);
2186   return builder_.Finish();
2187 }
2188
2189 inline flatbuffers::Offset<Uint16Vector>
2190 CreateUint16VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2191                          const std::vector<uint16_t> *values = nullptr)
2192 {
2193   return onert_tflite::CreateUint16Vector(_fbb, values ? _fbb.CreateVector<uint16_t>(*values) : 0);
2194 }
2195
2196 struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2197 {
2198   enum
2199   {
2200     VT_VALUES = 4
2201   };
2202   const flatbuffers::Vector<uint8_t> *values() const
2203   {
2204     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
2205   }
2206   bool Verify(flatbuffers::Verifier &verifier) const
2207   {
2208     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2209            verifier.VerifyVector(values()) && verifier.EndTable();
2210   }
2211 };
2212
2213 struct Uint8VectorBuilder
2214 {
2215   flatbuffers::FlatBufferBuilder &fbb_;
2216   flatbuffers::uoffset_t start_;
2217   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values)
2218   {
2219     fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
2220   }
2221   explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2222   {
2223     start_ = fbb_.StartTable();
2224   }
2225   Uint8VectorBuilder &operator=(const Uint8VectorBuilder &);
2226   flatbuffers::Offset<Uint8Vector> Finish()
2227   {
2228     const auto end = fbb_.EndTable(start_);
2229     auto o = flatbuffers::Offset<Uint8Vector>(end);
2230     return o;
2231   }
2232 };
2233
2234 inline flatbuffers::Offset<Uint8Vector>
2235 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb,
2236                   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0)
2237 {
2238   Uint8VectorBuilder builder_(_fbb);
2239   builder_.add_values(values);
2240   return builder_.Finish();
2241 }
2242
2243 inline flatbuffers::Offset<Uint8Vector>
2244 CreateUint8VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2245                         const std::vector<uint8_t> *values = nullptr)
2246 {
2247   return onert_tflite::CreateUint8Vector(_fbb, values ? _fbb.CreateVector<uint8_t>(*values) : 0);
2248 }
2249
2250 struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2251 {
2252   enum
2253   {
2254     VT_FORMAT = 4,
2255     VT_DENSE_SIZE = 6,
2256     VT_ARRAY_SEGMENTS_TYPE = 8,
2257     VT_ARRAY_SEGMENTS = 10,
2258     VT_ARRAY_INDICES_TYPE = 12,
2259     VT_ARRAY_INDICES = 14
2260   };
2261   DimensionType format() const
2262   {
2263     return static_cast<DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
2264   }
2265   int32_t dense_size() const { return GetField<int32_t>(VT_DENSE_SIZE, 0); }
2266   SparseIndexVector array_segments_type() const
2267   {
2268     return static_cast<SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
2269   }
2270   const void *array_segments() const { return GetPointer<const void *>(VT_ARRAY_SEGMENTS); }
2271   template <typename T> const T *array_segments_as() const;
2272   const Int32Vector *array_segments_as_Int32Vector() const
2273   {
2274     return array_segments_type() == SparseIndexVector_Int32Vector
2275                ? static_cast<const Int32Vector *>(array_segments())
2276                : nullptr;
2277   }
2278   const Uint16Vector *array_segments_as_Uint16Vector() const
2279   {
2280     return array_segments_type() == SparseIndexVector_Uint16Vector
2281                ? static_cast<const Uint16Vector *>(array_segments())
2282                : nullptr;
2283   }
2284   const Uint8Vector *array_segments_as_Uint8Vector() const
2285   {
2286     return array_segments_type() == SparseIndexVector_Uint8Vector
2287                ? static_cast<const Uint8Vector *>(array_segments())
2288                : nullptr;
2289   }
2290   SparseIndexVector array_indices_type() const
2291   {
2292     return static_cast<SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
2293   }
2294   const void *array_indices() const { return GetPointer<const void *>(VT_ARRAY_INDICES); }
2295   template <typename T> const T *array_indices_as() const;
2296   const Int32Vector *array_indices_as_Int32Vector() const
2297   {
2298     return array_indices_type() == SparseIndexVector_Int32Vector
2299                ? static_cast<const Int32Vector *>(array_indices())
2300                : nullptr;
2301   }
2302   const Uint16Vector *array_indices_as_Uint16Vector() const
2303   {
2304     return array_indices_type() == SparseIndexVector_Uint16Vector
2305                ? static_cast<const Uint16Vector *>(array_indices())
2306                : nullptr;
2307   }
2308   const Uint8Vector *array_indices_as_Uint8Vector() const
2309   {
2310     return array_indices_type() == SparseIndexVector_Uint8Vector
2311                ? static_cast<const Uint8Vector *>(array_indices())
2312                : nullptr;
2313   }
2314   bool Verify(flatbuffers::Verifier &verifier) const
2315   {
2316     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_FORMAT) &&
2317            VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
2318            VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
2319            VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
2320            VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
2321            VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
2322            VerifyOffset(verifier, VT_ARRAY_INDICES) &&
2323            VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
2324            verifier.EndTable();
2325   }
2326 };
2327
2328 template <> inline const Int32Vector *DimensionMetadata::array_segments_as<Int32Vector>() const
2329 {
2330   return array_segments_as_Int32Vector();
2331 }
2332
2333 template <> inline const Uint16Vector *DimensionMetadata::array_segments_as<Uint16Vector>() const
2334 {
2335   return array_segments_as_Uint16Vector();
2336 }
2337
2338 template <> inline const Uint8Vector *DimensionMetadata::array_segments_as<Uint8Vector>() const
2339 {
2340   return array_segments_as_Uint8Vector();
2341 }
2342
2343 template <> inline const Int32Vector *DimensionMetadata::array_indices_as<Int32Vector>() const
2344 {
2345   return array_indices_as_Int32Vector();
2346 }
2347
2348 template <> inline const Uint16Vector *DimensionMetadata::array_indices_as<Uint16Vector>() const
2349 {
2350   return array_indices_as_Uint16Vector();
2351 }
2352
2353 template <> inline const Uint8Vector *DimensionMetadata::array_indices_as<Uint8Vector>() const
2354 {
2355   return array_indices_as_Uint8Vector();
2356 }
2357
2358 struct DimensionMetadataBuilder
2359 {
2360   flatbuffers::FlatBufferBuilder &fbb_;
2361   flatbuffers::uoffset_t start_;
2362   void add_format(DimensionType format)
2363   {
2364     fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
2365   }
2366   void add_dense_size(int32_t dense_size)
2367   {
2368     fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
2369   }
2370   void add_array_segments_type(SparseIndexVector array_segments_type)
2371   {
2372     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE,
2373                              static_cast<uint8_t>(array_segments_type), 0);
2374   }
2375   void add_array_segments(flatbuffers::Offset<void> array_segments)
2376   {
2377     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
2378   }
2379   void add_array_indices_type(SparseIndexVector array_indices_type)
2380   {
2381     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE,
2382                              static_cast<uint8_t>(array_indices_type), 0);
2383   }
2384   void add_array_indices(flatbuffers::Offset<void> array_indices)
2385   {
2386     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
2387   }
2388   explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2389   {
2390     start_ = fbb_.StartTable();
2391   }
2392   DimensionMetadataBuilder &operator=(const DimensionMetadataBuilder &);
2393   flatbuffers::Offset<DimensionMetadata> Finish()
2394   {
2395     const auto end = fbb_.EndTable(start_);
2396     auto o = flatbuffers::Offset<DimensionMetadata>(end);
2397     return o;
2398   }
2399 };
2400
2401 inline flatbuffers::Offset<DimensionMetadata>
2402 CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb,
2403                         DimensionType format = DimensionType_DENSE, int32_t dense_size = 0,
2404                         SparseIndexVector array_segments_type = SparseIndexVector_NONE,
2405                         flatbuffers::Offset<void> array_segments = 0,
2406                         SparseIndexVector array_indices_type = SparseIndexVector_NONE,
2407                         flatbuffers::Offset<void> array_indices = 0)
2408 {
2409   DimensionMetadataBuilder builder_(_fbb);
2410   builder_.add_array_indices(array_indices);
2411   builder_.add_array_segments(array_segments);
2412   builder_.add_dense_size(dense_size);
2413   builder_.add_array_indices_type(array_indices_type);
2414   builder_.add_array_segments_type(array_segments_type);
2415   builder_.add_format(format);
2416   return builder_.Finish();
2417 }
2418
2419 struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2420 {
2421   enum
2422   {
2423     VT_TRAVERSAL_ORDER = 4,
2424     VT_BLOCK_MAP = 6,
2425     VT_DIM_METADATA = 8
2426   };
2427   const flatbuffers::Vector<int32_t> *traversal_order() const
2428   {
2429     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
2430   }
2431   const flatbuffers::Vector<int32_t> *block_map() const
2432   {
2433     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
2434   }
2435   const flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>> *dim_metadata() const
2436   {
2437     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>> *>(
2438         VT_DIM_METADATA);
2439   }
2440   bool Verify(flatbuffers::Verifier &verifier) const
2441   {
2442     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
2443            verifier.VerifyVector(traversal_order()) && VerifyOffset(verifier, VT_BLOCK_MAP) &&
2444            verifier.VerifyVector(block_map()) && VerifyOffset(verifier, VT_DIM_METADATA) &&
2445            verifier.VerifyVector(dim_metadata()) && verifier.VerifyVectorOfTables(dim_metadata()) &&
2446            verifier.EndTable();
2447   }
2448 };
2449
2450 struct SparsityParametersBuilder
2451 {
2452   flatbuffers::FlatBufferBuilder &fbb_;
2453   flatbuffers::uoffset_t start_;
2454   void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order)
2455   {
2456     fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
2457   }
2458   void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map)
2459   {
2460     fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
2461   }
2462   void add_dim_metadata(
2463       flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>>> dim_metadata)
2464   {
2465     fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
2466   }
2467   explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2468   {
2469     start_ = fbb_.StartTable();
2470   }
2471   SparsityParametersBuilder &operator=(const SparsityParametersBuilder &);
2472   flatbuffers::Offset<SparsityParameters> Finish()
2473   {
2474     const auto end = fbb_.EndTable(start_);
2475     auto o = flatbuffers::Offset<SparsityParameters>(end);
2476     return o;
2477   }
2478 };
2479
2480 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
2481     flatbuffers::FlatBufferBuilder &_fbb,
2482     flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
2483     flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
2484     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DimensionMetadata>>> dim_metadata =
2485         0)
2486 {
2487   SparsityParametersBuilder builder_(_fbb);
2488   builder_.add_dim_metadata(dim_metadata);
2489   builder_.add_block_map(block_map);
2490   builder_.add_traversal_order(traversal_order);
2491   return builder_.Finish();
2492 }
2493
2494 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
2495     flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *traversal_order = nullptr,
2496     const std::vector<int32_t> *block_map = nullptr,
2497     const std::vector<flatbuffers::Offset<DimensionMetadata>> *dim_metadata = nullptr)
2498 {
2499   return onert_tflite::CreateSparsityParameters(
2500       _fbb, traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0,
2501       block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0,
2502       dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<DimensionMetadata>>(*dim_metadata) : 0);
2503 }
2504
2505 struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2506 {
2507   enum
2508   {
2509     VT_SHAPE = 4,
2510     VT_TYPE = 6,
2511     VT_BUFFER = 8,
2512     VT_NAME = 10,
2513     VT_QUANTIZATION = 12,
2514     VT_IS_VARIABLE = 14,
2515     VT_SPARSITY = 16,
2516     VT_SHAPE_SIGNATURE = 18
2517   };
2518   const flatbuffers::Vector<int32_t> *shape() const
2519   {
2520     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
2521   }
2522   TensorType type() const { return static_cast<TensorType>(GetField<int8_t>(VT_TYPE, 0)); }
2523   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
2524   const flatbuffers::String *name() const
2525   {
2526     return GetPointer<const flatbuffers::String *>(VT_NAME);
2527   }
2528   const QuantizationParameters *quantization() const
2529   {
2530     return GetPointer<const QuantizationParameters *>(VT_QUANTIZATION);
2531   }
2532   bool is_variable() const { return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0; }
2533   const SparsityParameters *sparsity() const
2534   {
2535     return GetPointer<const SparsityParameters *>(VT_SPARSITY);
2536   }
2537   const flatbuffers::Vector<int32_t> *shape_signature() const
2538   {
2539     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
2540   }
2541   bool Verify(flatbuffers::Verifier &verifier) const
2542   {
2543     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) &&
2544            verifier.VerifyVector(shape()) && VerifyField<int8_t>(verifier, VT_TYPE) &&
2545            VerifyField<uint32_t>(verifier, VT_BUFFER) && VerifyOffset(verifier, VT_NAME) &&
2546            verifier.VerifyString(name()) && VerifyOffset(verifier, VT_QUANTIZATION) &&
2547            verifier.VerifyTable(quantization()) && VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
2548            VerifyOffset(verifier, VT_SPARSITY) && verifier.VerifyTable(sparsity()) &&
2549            VerifyOffset(verifier, VT_SHAPE_SIGNATURE) && verifier.VerifyVector(shape_signature()) &&
2550            verifier.EndTable();
2551   }
2552 };
2553
2554 struct TensorBuilder
2555 {
2556   flatbuffers::FlatBufferBuilder &fbb_;
2557   flatbuffers::uoffset_t start_;
2558   void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape)
2559   {
2560     fbb_.AddOffset(Tensor::VT_SHAPE, shape);
2561   }
2562   void add_type(TensorType type)
2563   {
2564     fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
2565   }
2566   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0); }
2567   void add_name(flatbuffers::Offset<flatbuffers::String> name)
2568   {
2569     fbb_.AddOffset(Tensor::VT_NAME, name);
2570   }
2571   void add_quantization(flatbuffers::Offset<QuantizationParameters> quantization)
2572   {
2573     fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
2574   }
2575   void add_is_variable(bool is_variable)
2576   {
2577     fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
2578   }
2579   void add_sparsity(flatbuffers::Offset<SparsityParameters> sparsity)
2580   {
2581     fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
2582   }
2583   void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature)
2584   {
2585     fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
2586   }
2587   explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2588   {
2589     start_ = fbb_.StartTable();
2590   }
2591   TensorBuilder &operator=(const TensorBuilder &);
2592   flatbuffers::Offset<Tensor> Finish()
2593   {
2594     const auto end = fbb_.EndTable(start_);
2595     auto o = flatbuffers::Offset<Tensor>(end);
2596     return o;
2597   }
2598 };
2599
2600 inline flatbuffers::Offset<Tensor>
2601 CreateTensor(flatbuffers::FlatBufferBuilder &_fbb,
2602              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
2603              TensorType type = TensorType_FLOAT32, uint32_t buffer = 0,
2604              flatbuffers::Offset<flatbuffers::String> name = 0,
2605              flatbuffers::Offset<QuantizationParameters> quantization = 0, bool is_variable = false,
2606              flatbuffers::Offset<SparsityParameters> sparsity = 0,
2607              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0)
2608 {
2609   TensorBuilder builder_(_fbb);
2610   builder_.add_shape_signature(shape_signature);
2611   builder_.add_sparsity(sparsity);
2612   builder_.add_quantization(quantization);
2613   builder_.add_name(name);
2614   builder_.add_buffer(buffer);
2615   builder_.add_shape(shape);
2616   builder_.add_is_variable(is_variable);
2617   builder_.add_type(type);
2618   return builder_.Finish();
2619 }
2620
2621 inline flatbuffers::Offset<Tensor> CreateTensorDirect(
2622     flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *shape = nullptr,
2623     TensorType type = TensorType_FLOAT32, uint32_t buffer = 0, const char *name = nullptr,
2624     flatbuffers::Offset<QuantizationParameters> quantization = 0, bool is_variable = false,
2625     flatbuffers::Offset<SparsityParameters> sparsity = 0,
2626     const std::vector<int32_t> *shape_signature = nullptr)
2627 {
2628   return onert_tflite::CreateTensor(
2629       _fbb, shape ? _fbb.CreateVector<int32_t>(*shape) : 0, type, buffer,
2630       name ? _fbb.CreateString(name) : 0, quantization, is_variable, sparsity,
2631       shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0);
2632 }
2633
2634 struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2635 {
2636   enum
2637   {
2638     VT_PADDING = 4,
2639     VT_STRIDE_W = 6,
2640     VT_STRIDE_H = 8,
2641     VT_FUSED_ACTIVATION_FUNCTION = 10,
2642     VT_DILATION_W_FACTOR = 12,
2643     VT_DILATION_H_FACTOR = 14
2644   };
2645   Padding padding() const { return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); }
2646   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
2647   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
2648   ActivationFunctionType fused_activation_function() const
2649   {
2650     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
2651   }
2652   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
2653   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
2654   bool Verify(flatbuffers::Verifier &verifier) const
2655   {
2656     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
2657            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
2658            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
2659            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
2660            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
2661            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
2662   }
2663 };
2664
2665 struct Conv2DOptionsBuilder
2666 {
2667   flatbuffers::FlatBufferBuilder &fbb_;
2668   flatbuffers::uoffset_t start_;
2669   void add_padding(Padding padding)
2670   {
2671     fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
2672   }
2673   void add_stride_w(int32_t stride_w)
2674   {
2675     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
2676   }
2677   void add_stride_h(int32_t stride_h)
2678   {
2679     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
2680   }
2681   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
2682   {
2683     fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
2684                             static_cast<int8_t>(fused_activation_function), 0);
2685   }
2686   void add_dilation_w_factor(int32_t dilation_w_factor)
2687   {
2688     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
2689   }
2690   void add_dilation_h_factor(int32_t dilation_h_factor)
2691   {
2692     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
2693   }
2694   explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2695   {
2696     start_ = fbb_.StartTable();
2697   }
2698   Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
2699   flatbuffers::Offset<Conv2DOptions> Finish()
2700   {
2701     const auto end = fbb_.EndTable(start_);
2702     auto o = flatbuffers::Offset<Conv2DOptions>(end);
2703     return o;
2704   }
2705 };
2706
2707 inline flatbuffers::Offset<Conv2DOptions>
2708 CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
2709                     int32_t stride_w = 0, int32_t stride_h = 0,
2710                     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
2711                     int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
2712 {
2713   Conv2DOptionsBuilder builder_(_fbb);
2714   builder_.add_dilation_h_factor(dilation_h_factor);
2715   builder_.add_dilation_w_factor(dilation_w_factor);
2716   builder_.add_stride_h(stride_h);
2717   builder_.add_stride_w(stride_w);
2718   builder_.add_fused_activation_function(fused_activation_function);
2719   builder_.add_padding(padding);
2720   return builder_.Finish();
2721 }
2722
2723 struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2724 {
2725   enum
2726   {
2727     VT_PADDING = 4,
2728     VT_STRIDE_W = 6,
2729     VT_STRIDE_H = 8,
2730     VT_FILTER_WIDTH = 10,
2731     VT_FILTER_HEIGHT = 12,
2732     VT_FUSED_ACTIVATION_FUNCTION = 14
2733   };
2734   Padding padding() const { return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); }
2735   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
2736   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
2737   int32_t filter_width() const { return GetField<int32_t>(VT_FILTER_WIDTH, 0); }
2738   int32_t filter_height() const { return GetField<int32_t>(VT_FILTER_HEIGHT, 0); }
2739   ActivationFunctionType fused_activation_function() const
2740   {
2741     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
2742   }
2743   bool Verify(flatbuffers::Verifier &verifier) const
2744   {
2745     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
2746            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
2747            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
2748            VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
2749            VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
2750            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
2751   }
2752 };
2753
2754 struct Pool2DOptionsBuilder
2755 {
2756   flatbuffers::FlatBufferBuilder &fbb_;
2757   flatbuffers::uoffset_t start_;
2758   void add_padding(Padding padding)
2759   {
2760     fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
2761   }
2762   void add_stride_w(int32_t stride_w)
2763   {
2764     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
2765   }
2766   void add_stride_h(int32_t stride_h)
2767   {
2768     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
2769   }
2770   void add_filter_width(int32_t filter_width)
2771   {
2772     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
2773   }
2774   void add_filter_height(int32_t filter_height)
2775   {
2776     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
2777   }
2778   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
2779   {
2780     fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
2781                             static_cast<int8_t>(fused_activation_function), 0);
2782   }
2783   explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2784   {
2785     start_ = fbb_.StartTable();
2786   }
2787   Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
2788   flatbuffers::Offset<Pool2DOptions> Finish()
2789   {
2790     const auto end = fbb_.EndTable(start_);
2791     auto o = flatbuffers::Offset<Pool2DOptions>(end);
2792     return o;
2793   }
2794 };
2795
2796 inline flatbuffers::Offset<Pool2DOptions>
2797 CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
2798                     int32_t stride_w = 0, int32_t stride_h = 0, int32_t filter_width = 0,
2799                     int32_t filter_height = 0,
2800                     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
2801 {
2802   Pool2DOptionsBuilder builder_(_fbb);
2803   builder_.add_filter_height(filter_height);
2804   builder_.add_filter_width(filter_width);
2805   builder_.add_stride_h(stride_h);
2806   builder_.add_stride_w(stride_w);
2807   builder_.add_fused_activation_function(fused_activation_function);
2808   builder_.add_padding(padding);
2809   return builder_.Finish();
2810 }
2811
2812 struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2813 {
2814   enum
2815   {
2816     VT_PADDING = 4,
2817     VT_STRIDE_W = 6,
2818     VT_STRIDE_H = 8,
2819     VT_DEPTH_MULTIPLIER = 10,
2820     VT_FUSED_ACTIVATION_FUNCTION = 12,
2821     VT_DILATION_W_FACTOR = 14,
2822     VT_DILATION_H_FACTOR = 16
2823   };
2824   Padding padding() const { return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); }
2825   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
2826   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
2827   int32_t depth_multiplier() const { return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0); }
2828   ActivationFunctionType fused_activation_function() const
2829   {
2830     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
2831   }
2832   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
2833   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
2834   bool Verify(flatbuffers::Verifier &verifier) const
2835   {
2836     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
2837            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
2838            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
2839            VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
2840            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
2841            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
2842            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
2843   }
2844 };
2845
2846 struct DepthwiseConv2DOptionsBuilder
2847 {
2848   flatbuffers::FlatBufferBuilder &fbb_;
2849   flatbuffers::uoffset_t start_;
2850   void add_padding(Padding padding)
2851   {
2852     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
2853   }
2854   void add_stride_w(int32_t stride_w)
2855   {
2856     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
2857   }
2858   void add_stride_h(int32_t stride_h)
2859   {
2860     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
2861   }
2862   void add_depth_multiplier(int32_t depth_multiplier)
2863   {
2864     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
2865   }
2866   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
2867   {
2868     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
2869                             static_cast<int8_t>(fused_activation_function), 0);
2870   }
2871   void add_dilation_w_factor(int32_t dilation_w_factor)
2872   {
2873     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
2874   }
2875   void add_dilation_h_factor(int32_t dilation_h_factor)
2876   {
2877     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
2878   }
2879   explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2880   {
2881     start_ = fbb_.StartTable();
2882   }
2883   DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
2884   flatbuffers::Offset<DepthwiseConv2DOptions> Finish()
2885   {
2886     const auto end = fbb_.EndTable(start_);
2887     auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
2888     return o;
2889   }
2890 };
2891
2892 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
2893     flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME, int32_t stride_w = 0,
2894     int32_t stride_h = 0, int32_t depth_multiplier = 0,
2895     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
2896     int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
2897 {
2898   DepthwiseConv2DOptionsBuilder builder_(_fbb);
2899   builder_.add_dilation_h_factor(dilation_h_factor);
2900   builder_.add_dilation_w_factor(dilation_w_factor);
2901   builder_.add_depth_multiplier(depth_multiplier);
2902   builder_.add_stride_h(stride_h);
2903   builder_.add_stride_w(stride_w);
2904   builder_.add_fused_activation_function(fused_activation_function);
2905   builder_.add_padding(padding);
2906   return builder_.Finish();
2907 }
2908
2909 struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2910 {
2911   enum
2912   {
2913     VT_NUM_CHANNELS = 4,
2914     VT_NUM_COLUMNS_PER_CHANNEL = 6,
2915     VT_EMBEDDING_DIM_PER_CHANNEL = 8
2916   };
2917   int32_t num_channels() const { return GetField<int32_t>(VT_NUM_CHANNELS, 0); }
2918   const flatbuffers::Vector<int32_t> *num_columns_per_channel() const
2919   {
2920     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
2921   }
2922   const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const
2923   {
2924     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
2925   }
2926   bool Verify(flatbuffers::Verifier &verifier) const
2927   {
2928     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
2929            VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
2930            verifier.VerifyVector(num_columns_per_channel()) &&
2931            VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
2932            verifier.VerifyVector(embedding_dim_per_channel()) && verifier.EndTable();
2933   }
2934 };
2935
2936 struct ConcatEmbeddingsOptionsBuilder
2937 {
2938   flatbuffers::FlatBufferBuilder &fbb_;
2939   flatbuffers::uoffset_t start_;
2940   void add_num_channels(int32_t num_channels)
2941   {
2942     fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
2943   }
2944   void add_num_columns_per_channel(
2945       flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel)
2946   {
2947     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
2948   }
2949   void add_embedding_dim_per_channel(
2950       flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel)
2951   {
2952     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL,
2953                    embedding_dim_per_channel);
2954   }
2955   explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2956   {
2957     start_ = fbb_.StartTable();
2958   }
2959   ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
2960   flatbuffers::Offset<ConcatEmbeddingsOptions> Finish()
2961   {
2962     const auto end = fbb_.EndTable(start_);
2963     auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
2964     return o;
2965   }
2966 };
2967
2968 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
2969     flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
2970     flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
2971     flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0)
2972 {
2973   ConcatEmbeddingsOptionsBuilder builder_(_fbb);
2974   builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
2975   builder_.add_num_columns_per_channel(num_columns_per_channel);
2976   builder_.add_num_channels(num_channels);
2977   return builder_.Finish();
2978 }
2979
2980 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
2981 CreateConcatEmbeddingsOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
2982                                     const std::vector<int32_t> *num_columns_per_channel = nullptr,
2983                                     const std::vector<int32_t> *embedding_dim_per_channel = nullptr)
2984 {
2985   return onert_tflite::CreateConcatEmbeddingsOptions(
2986       _fbb, num_channels,
2987       num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0,
2988       embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0);
2989 }
2990
2991 struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2992 {
2993   enum
2994   {
2995     VT_TYPE = 4
2996   };
2997   LSHProjectionType type() const
2998   {
2999     return static_cast<LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
3000   }
3001   bool Verify(flatbuffers::Verifier &verifier) const
3002   {
3003     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_TYPE) &&
3004            verifier.EndTable();
3005   }
3006 };
3007
3008 struct LSHProjectionOptionsBuilder
3009 {
3010   flatbuffers::FlatBufferBuilder &fbb_;
3011   flatbuffers::uoffset_t start_;
3012   void add_type(LSHProjectionType type)
3013   {
3014     fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
3015   }
3016   explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3017   {
3018     start_ = fbb_.StartTable();
3019   }
3020   LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
3021   flatbuffers::Offset<LSHProjectionOptions> Finish()
3022   {
3023     const auto end = fbb_.EndTable(start_);
3024     auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
3025     return o;
3026   }
3027 };
3028
3029 inline flatbuffers::Offset<LSHProjectionOptions>
3030 CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb,
3031                            LSHProjectionType type = LSHProjectionType_UNKNOWN)
3032 {
3033   LSHProjectionOptionsBuilder builder_(_fbb);
3034   builder_.add_type(type);
3035   return builder_.Finish();
3036 }
3037
3038 struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3039 {
3040   enum
3041   {
3042     VT_RANK = 4,
3043     VT_FUSED_ACTIVATION_FUNCTION = 6,
3044     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3045   };
3046   int32_t rank() const { return GetField<int32_t>(VT_RANK, 0); }
3047   ActivationFunctionType fused_activation_function() const
3048   {
3049     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3050   }
3051   bool asymmetric_quantize_inputs() const
3052   {
3053     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3054   }
3055   bool Verify(flatbuffers::Verifier &verifier) const
3056   {
3057     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RANK) &&
3058            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3059            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3060   }
3061 };
3062
3063 struct SVDFOptionsBuilder
3064 {
3065   flatbuffers::FlatBufferBuilder &fbb_;
3066   flatbuffers::uoffset_t start_;
3067   void add_rank(int32_t rank) { fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0); }
3068   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3069   {
3070     fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION,
3071                             static_cast<int8_t>(fused_activation_function), 0);
3072   }
3073   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3074   {
3075     fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3076                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3077   }
3078   explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3079   {
3080     start_ = fbb_.StartTable();
3081   }
3082   SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
3083   flatbuffers::Offset<SVDFOptions> Finish()
3084   {
3085     const auto end = fbb_.EndTable(start_);
3086     auto o = flatbuffers::Offset<SVDFOptions>(end);
3087     return o;
3088   }
3089 };
3090
3091 inline flatbuffers::Offset<SVDFOptions>
3092 CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0,
3093                   ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3094                   bool asymmetric_quantize_inputs = false)
3095 {
3096   SVDFOptionsBuilder builder_(_fbb);
3097   builder_.add_rank(rank);
3098   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3099   builder_.add_fused_activation_function(fused_activation_function);
3100   return builder_.Finish();
3101 }
3102
3103 struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3104 {
3105   enum
3106   {
3107     VT_FUSED_ACTIVATION_FUNCTION = 4,
3108     VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
3109   };
3110   ActivationFunctionType fused_activation_function() const
3111   {
3112     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3113   }
3114   bool asymmetric_quantize_inputs() const
3115   {
3116     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3117   }
3118   bool Verify(flatbuffers::Verifier &verifier) const
3119   {
3120     return VerifyTableStart(verifier) &&
3121            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3122            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3123   }
3124 };
3125
3126 struct RNNOptionsBuilder
3127 {
3128   flatbuffers::FlatBufferBuilder &fbb_;
3129   flatbuffers::uoffset_t start_;
3130   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3131   {
3132     fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3133                             static_cast<int8_t>(fused_activation_function), 0);
3134   }
3135   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3136   {
3137     fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3138                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3139   }
3140   explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3141   {
3142     start_ = fbb_.StartTable();
3143   }
3144   RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
3145   flatbuffers::Offset<RNNOptions> Finish()
3146   {
3147     const auto end = fbb_.EndTable(start_);
3148     auto o = flatbuffers::Offset<RNNOptions>(end);
3149     return o;
3150   }
3151 };
3152
3153 inline flatbuffers::Offset<RNNOptions>
3154 CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb,
3155                  ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3156                  bool asymmetric_quantize_inputs = false)
3157 {
3158   RNNOptionsBuilder builder_(_fbb);
3159   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3160   builder_.add_fused_activation_function(fused_activation_function);
3161   return builder_.Finish();
3162 }
3163
3164 struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3165 {
3166   enum
3167   {
3168     VT_TIME_MAJOR = 4,
3169     VT_FUSED_ACTIVATION_FUNCTION = 6,
3170     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3171   };
3172   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3173   ActivationFunctionType fused_activation_function() const
3174   {
3175     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3176   }
3177   bool asymmetric_quantize_inputs() const
3178   {
3179     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3180   }
3181   bool Verify(flatbuffers::Verifier &verifier) const
3182   {
3183     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3184            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3185            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3186   }
3187 };
3188
3189 struct SequenceRNNOptionsBuilder
3190 {
3191   flatbuffers::FlatBufferBuilder &fbb_;
3192   flatbuffers::uoffset_t start_;
3193   void add_time_major(bool time_major)
3194   {
3195     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major),
3196                              0);
3197   }
3198   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3199   {
3200     fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3201                             static_cast<int8_t>(fused_activation_function), 0);
3202   }
3203   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3204   {
3205     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3206                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3207   }
3208   explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3209   {
3210     start_ = fbb_.StartTable();
3211   }
3212   SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
3213   flatbuffers::Offset<SequenceRNNOptions> Finish()
3214   {
3215     const auto end = fbb_.EndTable(start_);
3216     auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
3217     return o;
3218   }
3219 };
3220
3221 inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
3222     flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3223     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3224     bool asymmetric_quantize_inputs = false)
3225 {
3226   SequenceRNNOptionsBuilder builder_(_fbb);
3227   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3228   builder_.add_fused_activation_function(fused_activation_function);
3229   builder_.add_time_major(time_major);
3230   return builder_.Finish();
3231 }
3232
3233 struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3234 {
3235   enum
3236   {
3237     VT_TIME_MAJOR = 4,
3238     VT_FUSED_ACTIVATION_FUNCTION = 6,
3239     VT_MERGE_OUTPUTS = 8,
3240     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3241   };
3242   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3243   ActivationFunctionType fused_activation_function() const
3244   {
3245     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3246   }
3247   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
3248   bool asymmetric_quantize_inputs() const
3249   {
3250     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3251   }
3252   bool Verify(flatbuffers::Verifier &verifier) const
3253   {
3254     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3255            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3256            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
3257            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3258   }
3259 };
3260
3261 struct BidirectionalSequenceRNNOptionsBuilder
3262 {
3263   flatbuffers::FlatBufferBuilder &fbb_;
3264   flatbuffers::uoffset_t start_;
3265   void add_time_major(bool time_major)
3266   {
3267     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR,
3268                              static_cast<uint8_t>(time_major), 0);
3269   }
3270   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3271   {
3272     fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3273                             static_cast<int8_t>(fused_activation_function), 0);
3274   }
3275   void add_merge_outputs(bool merge_outputs)
3276   {
3277     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS,
3278                              static_cast<uint8_t>(merge_outputs), 0);
3279   }
3280   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3281   {
3282     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3283                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3284   }
3285   explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3286   {
3287     start_ = fbb_.StartTable();
3288   }
3289   BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
3290   flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish()
3291   {
3292     const auto end = fbb_.EndTable(start_);
3293     auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
3294     return o;
3295   }
3296 };
3297
3298 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
3299     flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3300     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3301     bool merge_outputs = false, bool asymmetric_quantize_inputs = false)
3302 {
3303   BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
3304   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3305   builder_.add_merge_outputs(merge_outputs);
3306   builder_.add_fused_activation_function(fused_activation_function);
3307   builder_.add_time_major(time_major);
3308   return builder_.Finish();
3309 }
3310
3311 struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3312 {
3313   enum
3314   {
3315     VT_FUSED_ACTIVATION_FUNCTION = 4,
3316     VT_WEIGHTS_FORMAT = 6,
3317     VT_KEEP_NUM_DIMS = 8,
3318     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3319   };
3320   ActivationFunctionType fused_activation_function() const
3321   {
3322     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3323   }
3324   FullyConnectedOptionsWeightsFormat weights_format() const
3325   {
3326     return static_cast<FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
3327   }
3328   bool keep_num_dims() const { return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0; }
3329   bool asymmetric_quantize_inputs() const
3330   {
3331     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3332   }
3333   bool Verify(flatbuffers::Verifier &verifier) const
3334   {
3335     return VerifyTableStart(verifier) &&
3336            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3337            VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
3338            VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
3339            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3340   }
3341 };
3342
3343 struct FullyConnectedOptionsBuilder
3344 {
3345   flatbuffers::FlatBufferBuilder &fbb_;
3346   flatbuffers::uoffset_t start_;
3347   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3348   {
3349     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
3350                             static_cast<int8_t>(fused_activation_function), 0);
3351   }
3352   void add_weights_format(FullyConnectedOptionsWeightsFormat weights_format)
3353   {
3354     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT,
3355                             static_cast<int8_t>(weights_format), 0);
3356   }
3357   void add_keep_num_dims(bool keep_num_dims)
3358   {
3359     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS,
3360                              static_cast<uint8_t>(keep_num_dims), 0);
3361   }
3362   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3363   {
3364     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3365                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3366   }
3367   explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3368   {
3369     start_ = fbb_.StartTable();
3370   }
3371   FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
3372   flatbuffers::Offset<FullyConnectedOptions> Finish()
3373   {
3374     const auto end = fbb_.EndTable(start_);
3375     auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
3376     return o;
3377   }
3378 };
3379
3380 inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
3381     flatbuffers::FlatBufferBuilder &_fbb,
3382     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3383     FullyConnectedOptionsWeightsFormat weights_format = FullyConnectedOptionsWeightsFormat_DEFAULT,
3384     bool keep_num_dims = false, bool asymmetric_quantize_inputs = false)
3385 {
3386   FullyConnectedOptionsBuilder builder_(_fbb);
3387   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3388   builder_.add_keep_num_dims(keep_num_dims);
3389   builder_.add_weights_format(weights_format);
3390   builder_.add_fused_activation_function(fused_activation_function);
3391   return builder_.Finish();
3392 }
3393
3394 struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3395 {
3396   enum
3397   {
3398     VT_BETA = 4
3399   };
3400   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
3401   bool Verify(flatbuffers::Verifier &verifier) const
3402   {
3403     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_BETA) &&
3404            verifier.EndTable();
3405   }
3406 };
3407
3408 struct SoftmaxOptionsBuilder
3409 {
3410   flatbuffers::FlatBufferBuilder &fbb_;
3411   flatbuffers::uoffset_t start_;
3412   void add_beta(float beta) { fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f); }
3413   explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3414   {
3415     start_ = fbb_.StartTable();
3416   }
3417   SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
3418   flatbuffers::Offset<SoftmaxOptions> Finish()
3419   {
3420     const auto end = fbb_.EndTable(start_);
3421     auto o = flatbuffers::Offset<SoftmaxOptions>(end);
3422     return o;
3423   }
3424 };
3425
3426 inline flatbuffers::Offset<SoftmaxOptions>
3427 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f)
3428 {
3429   SoftmaxOptionsBuilder builder_(_fbb);
3430   builder_.add_beta(beta);
3431   return builder_.Finish();
3432 }
3433
3434 struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3435 {
3436   enum
3437   {
3438     VT_AXIS = 4,
3439     VT_FUSED_ACTIVATION_FUNCTION = 6
3440   };
3441   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
3442   ActivationFunctionType fused_activation_function() const
3443   {
3444     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3445   }
3446   bool Verify(flatbuffers::Verifier &verifier) const
3447   {
3448     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
3449            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3450   }
3451 };
3452
3453 struct ConcatenationOptionsBuilder
3454 {
3455   flatbuffers::FlatBufferBuilder &fbb_;
3456   flatbuffers::uoffset_t start_;
3457   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0); }
3458   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3459   {
3460     fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION,
3461                             static_cast<int8_t>(fused_activation_function), 0);
3462   }
3463   explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3464   {
3465     start_ = fbb_.StartTable();
3466   }
3467   ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
3468   flatbuffers::Offset<ConcatenationOptions> Finish()
3469   {
3470     const auto end = fbb_.EndTable(start_);
3471     auto o = flatbuffers::Offset<ConcatenationOptions>(end);
3472     return o;
3473   }
3474 };
3475
3476 inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
3477     flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0,
3478     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
3479 {
3480   ConcatenationOptionsBuilder builder_(_fbb);
3481   builder_.add_axis(axis);
3482   builder_.add_fused_activation_function(fused_activation_function);
3483   return builder_.Finish();
3484 }
3485
3486 struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3487 {
3488   enum
3489   {
3490     VT_FUSED_ACTIVATION_FUNCTION = 4
3491   };
3492   ActivationFunctionType fused_activation_function() const
3493   {
3494     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3495   }
3496   bool Verify(flatbuffers::Verifier &verifier) const
3497   {
3498     return VerifyTableStart(verifier) &&
3499            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3500   }
3501 };
3502
3503 struct AddOptionsBuilder
3504 {
3505   flatbuffers::FlatBufferBuilder &fbb_;
3506   flatbuffers::uoffset_t start_;
3507   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3508   {
3509     fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION,
3510                             static_cast<int8_t>(fused_activation_function), 0);
3511   }
3512   explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3513   {
3514     start_ = fbb_.StartTable();
3515   }
3516   AddOptionsBuilder &operator=(const AddOptionsBuilder &);
3517   flatbuffers::Offset<AddOptions> Finish()
3518   {
3519     const auto end = fbb_.EndTable(start_);
3520     auto o = flatbuffers::Offset<AddOptions>(end);
3521     return o;
3522   }
3523 };
3524
3525 inline flatbuffers::Offset<AddOptions>
3526 CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb,
3527                  ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
3528 {
3529   AddOptionsBuilder builder_(_fbb);
3530   builder_.add_fused_activation_function(fused_activation_function);
3531   return builder_.Finish();
3532 }
3533
3534 struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3535 {
3536   enum
3537   {
3538     VT_FUSED_ACTIVATION_FUNCTION = 4
3539   };
3540   ActivationFunctionType fused_activation_function() const
3541   {
3542     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3543   }
3544   bool Verify(flatbuffers::Verifier &verifier) const
3545   {
3546     return VerifyTableStart(verifier) &&
3547            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3548   }
3549 };
3550
3551 struct MulOptionsBuilder
3552 {
3553   flatbuffers::FlatBufferBuilder &fbb_;
3554   flatbuffers::uoffset_t start_;
3555   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3556   {
3557     fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION,
3558                             static_cast<int8_t>(fused_activation_function), 0);
3559   }
3560   explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3561   {
3562     start_ = fbb_.StartTable();
3563   }
3564   MulOptionsBuilder &operator=(const MulOptionsBuilder &);
3565   flatbuffers::Offset<MulOptions> Finish()
3566   {
3567     const auto end = fbb_.EndTable(start_);
3568     auto o = flatbuffers::Offset<MulOptions>(end);
3569     return o;
3570   }
3571 };
3572
3573 inline flatbuffers::Offset<MulOptions>
3574 CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb,
3575                  ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
3576 {
3577   MulOptionsBuilder builder_(_fbb);
3578   builder_.add_fused_activation_function(fused_activation_function);
3579   return builder_.Finish();
3580 }
3581
3582 struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3583 {
3584   enum
3585   {
3586     VT_FUSED_ACTIVATION_FUNCTION = 4
3587   };
3588   ActivationFunctionType fused_activation_function() const
3589   {
3590     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3591   }
3592   bool Verify(flatbuffers::Verifier &verifier) const
3593   {
3594     return VerifyTableStart(verifier) &&
3595            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3596   }
3597 };
3598
3599 struct L2NormOptionsBuilder
3600 {
3601   flatbuffers::FlatBufferBuilder &fbb_;
3602   flatbuffers::uoffset_t start_;
3603   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3604   {
3605     fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION,
3606                             static_cast<int8_t>(fused_activation_function), 0);
3607   }
3608   explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3609   {
3610     start_ = fbb_.StartTable();
3611   }
3612   L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
3613   flatbuffers::Offset<L2NormOptions> Finish()
3614   {
3615     const auto end = fbb_.EndTable(start_);
3616     auto o = flatbuffers::Offset<L2NormOptions>(end);
3617     return o;
3618   }
3619 };
3620
3621 inline flatbuffers::Offset<L2NormOptions>
3622 CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb,
3623                     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
3624 {
3625   L2NormOptionsBuilder builder_(_fbb);
3626   builder_.add_fused_activation_function(fused_activation_function);
3627   return builder_.Finish();
3628 }
3629
3630 struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3631 {
3632   enum
3633   {
3634     VT_RADIUS = 4,
3635     VT_BIAS = 6,
3636     VT_ALPHA = 8,
3637     VT_BETA = 10
3638   };
3639   int32_t radius() const { return GetField<int32_t>(VT_RADIUS, 0); }
3640   float bias() const { return GetField<float>(VT_BIAS, 0.0f); }
3641   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
3642   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
3643   bool Verify(flatbuffers::Verifier &verifier) const
3644   {
3645     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RADIUS) &&
3646            VerifyField<float>(verifier, VT_BIAS) && VerifyField<float>(verifier, VT_ALPHA) &&
3647            VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
3648   }
3649 };
3650
3651 struct LocalResponseNormalizationOptionsBuilder
3652 {
3653   flatbuffers::FlatBufferBuilder &fbb_;
3654   flatbuffers::uoffset_t start_;
3655   void add_radius(int32_t radius)
3656   {
3657     fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
3658   }
3659   void add_bias(float bias)
3660   {
3661     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
3662   }
3663   void add_alpha(float alpha)
3664   {
3665     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
3666   }
3667   void add_beta(float beta)
3668   {
3669     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
3670   }
3671   explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3672       : fbb_(_fbb)
3673   {
3674     start_ = fbb_.StartTable();
3675   }
3676   LocalResponseNormalizationOptionsBuilder &
3677   operator=(const LocalResponseNormalizationOptionsBuilder &);
3678   flatbuffers::Offset<LocalResponseNormalizationOptions> Finish()
3679   {
3680     const auto end = fbb_.EndTable(start_);
3681     auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
3682     return o;
3683   }
3684 };
3685
3686 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
3687 CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t radius = 0,
3688                                         float bias = 0.0f, float alpha = 0.0f, float beta = 0.0f)
3689 {
3690   LocalResponseNormalizationOptionsBuilder builder_(_fbb);
3691   builder_.add_beta(beta);
3692   builder_.add_alpha(alpha);
3693   builder_.add_bias(bias);
3694   builder_.add_radius(radius);
3695   return builder_.Finish();
3696 }
3697
3698 struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3699 {
3700   enum
3701   {
3702     VT_FUSED_ACTIVATION_FUNCTION = 4,
3703     VT_CELL_CLIP = 6,
3704     VT_PROJ_CLIP = 8,
3705     VT_KERNEL_TYPE = 10,
3706     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
3707   };
3708   ActivationFunctionType fused_activation_function() const
3709   {
3710     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3711   }
3712   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
3713   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
3714   LSTMKernelType kernel_type() const
3715   {
3716     return static_cast<LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
3717   }
3718   bool asymmetric_quantize_inputs() const
3719   {
3720     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3721   }
3722   bool Verify(flatbuffers::Verifier &verifier) const
3723   {
3724     return VerifyTableStart(verifier) &&
3725            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3726            VerifyField<float>(verifier, VT_CELL_CLIP) &&
3727            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
3728            VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
3729            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3730   }
3731 };
3732
3733 struct LSTMOptionsBuilder
3734 {
3735   flatbuffers::FlatBufferBuilder &fbb_;
3736   flatbuffers::uoffset_t start_;
3737   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3738   {
3739     fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
3740                             static_cast<int8_t>(fused_activation_function), 0);
3741   }
3742   void add_cell_clip(float cell_clip)
3743   {
3744     fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
3745   }
3746   void add_proj_clip(float proj_clip)
3747   {
3748     fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
3749   }
3750   void add_kernel_type(LSTMKernelType kernel_type)
3751   {
3752     fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
3753   }
3754   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3755   {
3756     fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3757                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3758   }
3759   explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3760   {
3761     start_ = fbb_.StartTable();
3762   }
3763   LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
3764   flatbuffers::Offset<LSTMOptions> Finish()
3765   {
3766     const auto end = fbb_.EndTable(start_);
3767     auto o = flatbuffers::Offset<LSTMOptions>(end);
3768     return o;
3769   }
3770 };
3771
3772 inline flatbuffers::Offset<LSTMOptions>
3773 CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb,
3774                   ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3775                   float cell_clip = 0.0f, float proj_clip = 0.0f,
3776                   LSTMKernelType kernel_type = LSTMKernelType_FULL,
3777                   bool asymmetric_quantize_inputs = false)
3778 {
3779   LSTMOptionsBuilder builder_(_fbb);
3780   builder_.add_proj_clip(proj_clip);
3781   builder_.add_cell_clip(cell_clip);
3782   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3783   builder_.add_kernel_type(kernel_type);
3784   builder_.add_fused_activation_function(fused_activation_function);
3785   return builder_.Finish();
3786 }
3787
3788 struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3789 {
3790   enum
3791   {
3792     VT_FUSED_ACTIVATION_FUNCTION = 4,
3793     VT_CELL_CLIP = 6,
3794     VT_PROJ_CLIP = 8,
3795     VT_TIME_MAJOR = 10,
3796     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
3797   };
3798   ActivationFunctionType fused_activation_function() const
3799   {
3800     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3801   }
3802   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
3803   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
3804   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3805   bool asymmetric_quantize_inputs() const
3806   {
3807     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3808   }
3809   bool Verify(flatbuffers::Verifier &verifier) const
3810   {
3811     return VerifyTableStart(verifier) &&
3812            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3813            VerifyField<float>(verifier, VT_CELL_CLIP) &&
3814            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
3815            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3816            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3817   }
3818 };
3819
3820 struct UnidirectionalSequenceLSTMOptionsBuilder
3821 {
3822   flatbuffers::FlatBufferBuilder &fbb_;
3823   flatbuffers::uoffset_t start_;
3824   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3825   {
3826     fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
3827                             static_cast<int8_t>(fused_activation_function), 0);
3828   }
3829   void add_cell_clip(float cell_clip)
3830   {
3831     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
3832   }
3833   void add_proj_clip(float proj_clip)
3834   {
3835     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
3836   }
3837   void add_time_major(bool time_major)
3838   {
3839     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
3840                              static_cast<uint8_t>(time_major), 0);
3841   }
3842   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3843   {
3844     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3845                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3846   }
3847   explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3848       : fbb_(_fbb)
3849   {
3850     start_ = fbb_.StartTable();
3851   }
3852   UnidirectionalSequenceLSTMOptionsBuilder &
3853   operator=(const UnidirectionalSequenceLSTMOptionsBuilder &);
3854   flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish()
3855   {
3856     const auto end = fbb_.EndTable(start_);
3857     auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
3858     return o;
3859   }
3860 };
3861
3862 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
3863 CreateUnidirectionalSequenceLSTMOptions(
3864     flatbuffers::FlatBufferBuilder &_fbb,
3865     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3866     float cell_clip = 0.0f, float proj_clip = 0.0f, bool time_major = false,
3867     bool asymmetric_quantize_inputs = false)
3868 {
3869   UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
3870   builder_.add_proj_clip(proj_clip);
3871   builder_.add_cell_clip(cell_clip);
3872   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3873   builder_.add_time_major(time_major);
3874   builder_.add_fused_activation_function(fused_activation_function);
3875   return builder_.Finish();
3876 }
3877
3878 struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3879 {
3880   enum
3881   {
3882     VT_FUSED_ACTIVATION_FUNCTION = 4,
3883     VT_CELL_CLIP = 6,
3884     VT_PROJ_CLIP = 8,
3885     VT_MERGE_OUTPUTS = 10,
3886     VT_TIME_MAJOR = 12,
3887     VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
3888   };
3889   ActivationFunctionType fused_activation_function() const
3890   {
3891     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3892   }
3893   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
3894   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
3895   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
3896   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0; }
3897   bool asymmetric_quantize_inputs() const
3898   {
3899     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3900   }
3901   bool Verify(flatbuffers::Verifier &verifier) const
3902   {
3903     return VerifyTableStart(verifier) &&
3904            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3905            VerifyField<float>(verifier, VT_CELL_CLIP) &&
3906            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
3907            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
3908            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3909            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3910   }
3911 };
3912
3913 struct BidirectionalSequenceLSTMOptionsBuilder
3914 {
3915   flatbuffers::FlatBufferBuilder &fbb_;
3916   flatbuffers::uoffset_t start_;
3917   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
3918   {
3919     fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
3920                             static_cast<int8_t>(fused_activation_function), 0);
3921   }
3922   void add_cell_clip(float cell_clip)
3923   {
3924     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
3925   }
3926   void add_proj_clip(float proj_clip)
3927   {
3928     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
3929   }
3930   void add_merge_outputs(bool merge_outputs)
3931   {
3932     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS,
3933                              static_cast<uint8_t>(merge_outputs), 0);
3934   }
3935   void add_time_major(bool time_major)
3936   {
3937     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
3938                              static_cast<uint8_t>(time_major), 1);
3939   }
3940   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3941   {
3942     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3943                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3944   }
3945   explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3946       : fbb_(_fbb)
3947   {
3948     start_ = fbb_.StartTable();
3949   }
3950   BidirectionalSequenceLSTMOptionsBuilder &
3951   operator=(const BidirectionalSequenceLSTMOptionsBuilder &);
3952   flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish()
3953   {
3954     const auto end = fbb_.EndTable(start_);
3955     auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
3956     return o;
3957   }
3958 };
3959
3960 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
3961     flatbuffers::FlatBufferBuilder &_fbb,
3962     ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE,
3963     float cell_clip = 0.0f, float proj_clip = 0.0f, bool merge_outputs = false,
3964     bool time_major = true, bool asymmetric_quantize_inputs = false)
3965 {
3966   BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
3967   builder_.add_proj_clip(proj_clip);
3968   builder_.add_cell_clip(cell_clip);
3969   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3970   builder_.add_time_major(time_major);
3971   builder_.add_merge_outputs(merge_outputs);
3972   builder_.add_fused_activation_function(fused_activation_function);
3973   return builder_.Finish();
3974 }
3975
3976 struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3977 {
3978   enum
3979   {
3980     VT_ALIGN_CORNERS = 8,
3981     VT_HALF_PIXEL_CENTERS = 10
3982   };
3983   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
3984   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
3985   bool Verify(flatbuffers::Verifier &verifier) const
3986   {
3987     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
3988            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
3989   }
3990 };
3991
3992 struct ResizeBilinearOptionsBuilder
3993 {
3994   flatbuffers::FlatBufferBuilder &fbb_;
3995   flatbuffers::uoffset_t start_;
3996   void add_align_corners(bool align_corners)
3997   {
3998     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS,
3999                              static_cast<uint8_t>(align_corners), 0);
4000   }
4001   void add_half_pixel_centers(bool half_pixel_centers)
4002   {
4003     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS,
4004                              static_cast<uint8_t>(half_pixel_centers), 0);
4005   }
4006   explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4007   {
4008     start_ = fbb_.StartTable();
4009   }
4010   ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
4011   flatbuffers::Offset<ResizeBilinearOptions> Finish()
4012   {
4013     const auto end = fbb_.EndTable(start_);
4014     auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
4015     return o;
4016   }
4017 };
4018
4019 inline flatbuffers::Offset<ResizeBilinearOptions>
4020 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
4021                             bool half_pixel_centers = false)
4022 {
4023   ResizeBilinearOptionsBuilder builder_(_fbb);
4024   builder_.add_half_pixel_centers(half_pixel_centers);
4025   builder_.add_align_corners(align_corners);
4026   return builder_.Finish();
4027 }
4028
4029 struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4030 {
4031   enum
4032   {
4033     VT_ALIGN_CORNERS = 4
4034   };
4035   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
4036   bool Verify(flatbuffers::Verifier &verifier) const
4037   {
4038     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
4039            verifier.EndTable();
4040   }
4041 };
4042
4043 struct ResizeNearestNeighborOptionsBuilder
4044 {
4045   flatbuffers::FlatBufferBuilder &fbb_;
4046   flatbuffers::uoffset_t start_;
4047   void add_align_corners(bool align_corners)
4048   {
4049     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS,
4050                              static_cast<uint8_t>(align_corners), 0);
4051   }
4052   explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4053   {
4054     start_ = fbb_.StartTable();
4055   }
4056   ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &);
4057   flatbuffers::Offset<ResizeNearestNeighborOptions> Finish()
4058   {
4059     const auto end = fbb_.EndTable(start_);
4060     auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
4061     return o;
4062   }
4063 };
4064
4065 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
4066 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false)
4067 {
4068   ResizeNearestNeighborOptionsBuilder builder_(_fbb);
4069   builder_.add_align_corners(align_corners);
4070   return builder_.Finish();
4071 }
4072
4073 struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4074 {
4075   enum
4076   {
4077     VT_SUBGRAPH = 4
4078   };
4079   uint32_t subgraph() const { return GetField<uint32_t>(VT_SUBGRAPH, 0); }
4080   bool Verify(flatbuffers::Verifier &verifier) const
4081   {
4082     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
4083            verifier.EndTable();
4084   }
4085 };
4086
4087 struct CallOptionsBuilder
4088 {
4089   flatbuffers::FlatBufferBuilder &fbb_;
4090   flatbuffers::uoffset_t start_;
4091   void add_subgraph(uint32_t subgraph)
4092   {
4093     fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
4094   }
4095   explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4096   {
4097     start_ = fbb_.StartTable();
4098   }
4099   CallOptionsBuilder &operator=(const CallOptionsBuilder &);
4100   flatbuffers::Offset<CallOptions> Finish()
4101   {
4102     const auto end = fbb_.EndTable(start_);
4103     auto o = flatbuffers::Offset<CallOptions>(end);
4104     return o;
4105   }
4106 };
4107
4108 inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb,
4109                                                           uint32_t subgraph = 0)
4110 {
4111   CallOptionsBuilder builder_(_fbb);
4112   builder_.add_subgraph(subgraph);
4113   return builder_.Finish();
4114 }
4115
4116 struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4117 {
4118   bool Verify(flatbuffers::Verifier &verifier) const
4119   {
4120     return VerifyTableStart(verifier) && verifier.EndTable();
4121   }
4122 };
4123
4124 struct PadOptionsBuilder
4125 {
4126   flatbuffers::FlatBufferBuilder &fbb_;
4127   flatbuffers::uoffset_t start_;
4128   explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4129   {
4130     start_ = fbb_.StartTable();
4131   }
4132   PadOptionsBuilder &operator=(const PadOptionsBuilder &);
4133   flatbuffers::Offset<PadOptions> Finish()
4134   {
4135     const auto end = fbb_.EndTable(start_);
4136     auto o = flatbuffers::Offset<PadOptions>(end);
4137     return o;
4138   }
4139 };
4140
4141 inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb)
4142 {
4143   PadOptionsBuilder builder_(_fbb);
4144   return builder_.Finish();
4145 }
4146
4147 struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4148 {
4149   bool Verify(flatbuffers::Verifier &verifier) const
4150   {
4151     return VerifyTableStart(verifier) && verifier.EndTable();
4152   }
4153 };
4154
4155 struct PadV2OptionsBuilder
4156 {
4157   flatbuffers::FlatBufferBuilder &fbb_;
4158   flatbuffers::uoffset_t start_;
4159   explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4160   {
4161     start_ = fbb_.StartTable();
4162   }
4163   PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &);
4164   flatbuffers::Offset<PadV2Options> Finish()
4165   {
4166     const auto end = fbb_.EndTable(start_);
4167     auto o = flatbuffers::Offset<PadV2Options>(end);
4168     return o;
4169   }
4170 };
4171
4172 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb)
4173 {
4174   PadV2OptionsBuilder builder_(_fbb);
4175   return builder_.Finish();
4176 }
4177
4178 struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4179 {
4180   enum
4181   {
4182     VT_NEW_SHAPE = 4
4183   };
4184   const flatbuffers::Vector<int32_t> *new_shape() const
4185   {
4186     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
4187   }
4188   bool Verify(flatbuffers::Verifier &verifier) const
4189   {
4190     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) &&
4191            verifier.VerifyVector(new_shape()) && verifier.EndTable();
4192   }
4193 };
4194
4195 struct ReshapeOptionsBuilder
4196 {
4197   flatbuffers::FlatBufferBuilder &fbb_;
4198   flatbuffers::uoffset_t start_;
4199   void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape)
4200   {
4201     fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
4202   }
4203   explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4204   {
4205     start_ = fbb_.StartTable();
4206   }
4207   ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
4208   flatbuffers::Offset<ReshapeOptions> Finish()
4209   {
4210     const auto end = fbb_.EndTable(start_);
4211     auto o = flatbuffers::Offset<ReshapeOptions>(end);
4212     return o;
4213   }
4214 };
4215
4216 inline flatbuffers::Offset<ReshapeOptions>
4217 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
4218                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0)
4219 {
4220   ReshapeOptionsBuilder builder_(_fbb);
4221   builder_.add_new_shape(new_shape);
4222   return builder_.Finish();
4223 }
4224
4225 inline flatbuffers::Offset<ReshapeOptions>
4226 CreateReshapeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
4227                            const std::vector<int32_t> *new_shape = nullptr)
4228 {
4229   return onert_tflite::CreateReshapeOptions(_fbb,
4230                                             new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0);
4231 }
4232
4233 struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4234 {
4235   bool Verify(flatbuffers::Verifier &verifier) const
4236   {
4237     return VerifyTableStart(verifier) && verifier.EndTable();
4238   }
4239 };
4240
4241 struct SpaceToBatchNDOptionsBuilder
4242 {
4243   flatbuffers::FlatBufferBuilder &fbb_;
4244   flatbuffers::uoffset_t start_;
4245   explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4246   {
4247     start_ = fbb_.StartTable();
4248   }
4249   SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
4250   flatbuffers::Offset<SpaceToBatchNDOptions> Finish()
4251   {
4252     const auto end = fbb_.EndTable(start_);
4253     auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
4254     return o;
4255   }
4256 };
4257
4258 inline flatbuffers::Offset<SpaceToBatchNDOptions>
4259 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
4260 {
4261   SpaceToBatchNDOptionsBuilder builder_(_fbb);
4262   return builder_.Finish();
4263 }
4264
4265 struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4266 {
4267   bool Verify(flatbuffers::Verifier &verifier) const
4268   {
4269     return VerifyTableStart(verifier) && verifier.EndTable();
4270   }
4271 };
4272
4273 struct BatchToSpaceNDOptionsBuilder
4274 {
4275   flatbuffers::FlatBufferBuilder &fbb_;
4276   flatbuffers::uoffset_t start_;
4277   explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4278   {
4279     start_ = fbb_.StartTable();
4280   }
4281   BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
4282   flatbuffers::Offset<BatchToSpaceNDOptions> Finish()
4283   {
4284     const auto end = fbb_.EndTable(start_);
4285     auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
4286     return o;
4287   }
4288 };
4289
4290 inline flatbuffers::Offset<BatchToSpaceNDOptions>
4291 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
4292 {
4293   BatchToSpaceNDOptionsBuilder builder_(_fbb);
4294   return builder_.Finish();
4295 }
4296
4297 struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4298 {
4299   enum
4300   {
4301     VT_NGRAM_SIZE = 4,
4302     VT_MAX_SKIP_SIZE = 6,
4303     VT_INCLUDE_ALL_NGRAMS = 8
4304   };
4305   int32_t ngram_size() const { return GetField<int32_t>(VT_NGRAM_SIZE, 0); }
4306   int32_t max_skip_size() const { return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0); }
4307   bool include_all_ngrams() const { return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0; }
4308   bool Verify(flatbuffers::Verifier &verifier) const
4309   {
4310     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
4311            VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
4312            VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) && verifier.EndTable();
4313   }
4314 };
4315
4316 struct SkipGramOptionsBuilder
4317 {
4318   flatbuffers::FlatBufferBuilder &fbb_;
4319   flatbuffers::uoffset_t start_;
4320   void add_ngram_size(int32_t ngram_size)
4321   {
4322     fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
4323   }
4324   void add_max_skip_size(int32_t max_skip_size)
4325   {
4326     fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
4327   }
4328   void add_include_all_ngrams(bool include_all_ngrams)
4329   {
4330     fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS,
4331                              static_cast<uint8_t>(include_all_ngrams), 0);
4332   }
4333   explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4334   {
4335     start_ = fbb_.StartTable();
4336   }
4337   SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
4338   flatbuffers::Offset<SkipGramOptions> Finish()
4339   {
4340     const auto end = fbb_.EndTable(start_);
4341     auto o = flatbuffers::Offset<SkipGramOptions>(end);
4342     return o;
4343   }
4344 };
4345
4346 inline flatbuffers::Offset<SkipGramOptions>
4347 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0,
4348                       int32_t max_skip_size = 0, bool include_all_ngrams = false)
4349 {
4350   SkipGramOptionsBuilder builder_(_fbb);
4351   builder_.add_max_skip_size(max_skip_size);
4352   builder_.add_ngram_size(ngram_size);
4353   builder_.add_include_all_ngrams(include_all_ngrams);
4354   return builder_.Finish();
4355 }
4356
4357 struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4358 {
4359   enum
4360   {
4361     VT_BLOCK_SIZE = 4
4362   };
4363   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
4364   bool Verify(flatbuffers::Verifier &verifier) const
4365   {
4366     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
4367            verifier.EndTable();
4368   }
4369 };
4370
4371 struct SpaceToDepthOptionsBuilder
4372 {
4373   flatbuffers::FlatBufferBuilder &fbb_;
4374   flatbuffers::uoffset_t start_;
4375   void add_block_size(int32_t block_size)
4376   {
4377     fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
4378   }
4379   explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4380   {
4381     start_ = fbb_.StartTable();
4382   }
4383   SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
4384   flatbuffers::Offset<SpaceToDepthOptions> Finish()
4385   {
4386     const auto end = fbb_.EndTable(start_);
4387     auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
4388     return o;
4389   }
4390 };
4391
4392 inline flatbuffers::Offset<SpaceToDepthOptions>
4393 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
4394 {
4395   SpaceToDepthOptionsBuilder builder_(_fbb);
4396   builder_.add_block_size(block_size);
4397   return builder_.Finish();
4398 }
4399
4400 struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4401 {
4402   enum
4403   {
4404     VT_BLOCK_SIZE = 4
4405   };
4406   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
4407   bool Verify(flatbuffers::Verifier &verifier) const
4408   {
4409     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
4410            verifier.EndTable();
4411   }
4412 };
4413
4414 struct DepthToSpaceOptionsBuilder
4415 {
4416   flatbuffers::FlatBufferBuilder &fbb_;
4417   flatbuffers::uoffset_t start_;
4418   void add_block_size(int32_t block_size)
4419   {
4420     fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
4421   }
4422   explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4423   {
4424     start_ = fbb_.StartTable();
4425   }
4426   DepthToSpaceOptionsBuilder &operator=(const DepthToSpaceOptionsBuilder &);
4427   flatbuffers::Offset<DepthToSpaceOptions> Finish()
4428   {
4429     const auto end = fbb_.EndTable(start_);
4430     auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
4431     return o;
4432   }
4433 };
4434
4435 inline flatbuffers::Offset<DepthToSpaceOptions>
4436 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
4437 {
4438   DepthToSpaceOptionsBuilder builder_(_fbb);
4439   builder_.add_block_size(block_size);
4440   return builder_.Finish();
4441 }
4442
4443 struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4444 {
4445   enum
4446   {
4447     VT_FUSED_ACTIVATION_FUNCTION = 4
4448   };
4449   ActivationFunctionType fused_activation_function() const
4450   {
4451     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4452   }
4453   bool Verify(flatbuffers::Verifier &verifier) const
4454   {
4455     return VerifyTableStart(verifier) &&
4456            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4457   }
4458 };
4459
4460 struct SubOptionsBuilder
4461 {
4462   flatbuffers::FlatBufferBuilder &fbb_;
4463   flatbuffers::uoffset_t start_;
4464   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
4465   {
4466     fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION,
4467                             static_cast<int8_t>(fused_activation_function), 0);
4468   }
4469   explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4470   {
4471     start_ = fbb_.StartTable();
4472   }
4473   SubOptionsBuilder &operator=(const SubOptionsBuilder &);
4474   flatbuffers::Offset<SubOptions> Finish()
4475   {
4476     const auto end = fbb_.EndTable(start_);
4477     auto o = flatbuffers::Offset<SubOptions>(end);
4478     return o;
4479   }
4480 };
4481
4482 inline flatbuffers::Offset<SubOptions>
4483 CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb,
4484                  ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
4485 {
4486   SubOptionsBuilder builder_(_fbb);
4487   builder_.add_fused_activation_function(fused_activation_function);
4488   return builder_.Finish();
4489 }
4490
4491 struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4492 {
4493   enum
4494   {
4495     VT_FUSED_ACTIVATION_FUNCTION = 4
4496   };
4497   ActivationFunctionType fused_activation_function() const
4498   {
4499     return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4500   }
4501   bool Verify(flatbuffers::Verifier &verifier) const
4502   {
4503     return VerifyTableStart(verifier) &&
4504            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4505   }
4506 };
4507
4508 struct DivOptionsBuilder
4509 {
4510   flatbuffers::FlatBufferBuilder &fbb_;
4511   flatbuffers::uoffset_t start_;
4512   void add_fused_activation_function(ActivationFunctionType fused_activation_function)
4513   {
4514     fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION,
4515                             static_cast<int8_t>(fused_activation_function), 0);
4516   }
4517   explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4518   {
4519     start_ = fbb_.StartTable();
4520   }
4521   DivOptionsBuilder &operator=(const DivOptionsBuilder &);
4522   flatbuffers::Offset<DivOptions> Finish()
4523   {
4524     const auto end = fbb_.EndTable(start_);
4525     auto o = flatbuffers::Offset<DivOptions>(end);
4526     return o;
4527   }
4528 };
4529
4530 inline flatbuffers::Offset<DivOptions>
4531 CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb,
4532                  ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
4533 {
4534   DivOptionsBuilder builder_(_fbb);
4535   builder_.add_fused_activation_function(fused_activation_function);
4536   return builder_.Finish();
4537 }
4538
4539 struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4540 {
4541   bool Verify(flatbuffers::Verifier &verifier) const
4542   {
4543     return VerifyTableStart(verifier) && verifier.EndTable();
4544   }
4545 };
4546
4547 struct TopKV2OptionsBuilder
4548 {
4549   flatbuffers::FlatBufferBuilder &fbb_;
4550   flatbuffers::uoffset_t start_;
4551   explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4552   {
4553     start_ = fbb_.StartTable();
4554   }
4555   TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &);
4556   flatbuffers::Offset<TopKV2Options> Finish()
4557   {
4558     const auto end = fbb_.EndTable(start_);
4559     auto o = flatbuffers::Offset<TopKV2Options>(end);
4560     return o;
4561   }
4562 };
4563
4564 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb)
4565 {
4566   TopKV2OptionsBuilder builder_(_fbb);
4567   return builder_.Finish();
4568 }
4569
4570 struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4571 {
4572   enum
4573   {
4574     VT_COMBINER = 4
4575   };
4576   CombinerType combiner() const
4577   {
4578     return static_cast<CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
4579   }
4580   bool Verify(flatbuffers::Verifier &verifier) const
4581   {
4582     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_COMBINER) &&
4583            verifier.EndTable();
4584   }
4585 };
4586
4587 struct EmbeddingLookupSparseOptionsBuilder
4588 {
4589   flatbuffers::FlatBufferBuilder &fbb_;
4590   flatbuffers::uoffset_t start_;
4591   void add_combiner(CombinerType combiner)
4592   {
4593     fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER,
4594                             static_cast<int8_t>(combiner), 0);
4595   }
4596   explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4597   {
4598     start_ = fbb_.StartTable();
4599   }
4600   EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
4601   flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish()
4602   {
4603     const auto end = fbb_.EndTable(start_);
4604     auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
4605     return o;
4606   }
4607 };
4608
4609 inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
4610 CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
4611                                    CombinerType combiner = CombinerType_SUM)
4612 {
4613   EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
4614   builder_.add_combiner(combiner);
4615   return builder_.Finish();
4616 }
4617
4618 struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4619 {
4620   enum
4621   {
4622     VT_AXIS = 4
4623   };
4624   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
4625   bool Verify(flatbuffers::Verifier &verifier) const
4626   {
4627     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
4628            verifier.EndTable();
4629   }
4630 };
4631
4632 struct GatherOptionsBuilder
4633 {
4634   flatbuffers::FlatBufferBuilder &fbb_;
4635   flatbuffers::uoffset_t start_;
4636   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0); }
4637   explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4638   {
4639     start_ = fbb_.StartTable();
4640   }
4641   GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
4642   flatbuffers::Offset<GatherOptions> Finish()
4643   {
4644     const auto end = fbb_.EndTable(start_);
4645     auto o = flatbuffers::Offset<GatherOptions>(end);
4646     return o;
4647   }
4648 };
4649
4650 inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb,
4651                                                               int32_t axis = 0)
4652 {
4653   GatherOptionsBuilder builder_(_fbb);
4654   builder_.add_axis(axis);
4655   return builder_.Finish();
4656 }
4657
4658 struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4659 {
4660   bool Verify(flatbuffers::Verifier &verifier) const
4661   {
4662     return VerifyTableStart(verifier) && verifier.EndTable();
4663   }
4664 };
4665
4666 struct TransposeOptionsBuilder
4667 {
4668   flatbuffers::FlatBufferBuilder &fbb_;
4669   flatbuffers::uoffset_t start_;
4670   explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4671   {
4672     start_ = fbb_.StartTable();
4673   }
4674   TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
4675   flatbuffers::Offset<TransposeOptions> Finish()
4676   {
4677     const auto end = fbb_.EndTable(start_);
4678     auto o = flatbuffers::Offset<TransposeOptions>(end);
4679     return o;
4680   }
4681 };
4682
4683 inline flatbuffers::Offset<TransposeOptions>
4684 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb)
4685 {
4686   TransposeOptionsBuilder builder_(_fbb);
4687   return builder_.Finish();
4688 }
4689
4690 struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4691 {
4692   bool Verify(flatbuffers::Verifier &verifier) const
4693   {
4694     return VerifyTableStart(verifier) && verifier.EndTable();
4695   }
4696 };
4697
4698 struct ExpOptionsBuilder
4699 {
4700   flatbuffers::FlatBufferBuilder &fbb_;
4701   flatbuffers::uoffset_t start_;
4702   explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4703   {
4704     start_ = fbb_.StartTable();
4705   }
4706   ExpOptionsBuilder &operator=(const ExpOptionsBuilder &);
4707   flatbuffers::Offset<ExpOptions> Finish()
4708   {
4709     const auto end = fbb_.EndTable(start_);
4710     auto o = flatbuffers::Offset<ExpOptions>(end);
4711     return o;
4712   }
4713 };
4714
4715 inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb)
4716 {
4717   ExpOptionsBuilder builder_(_fbb);
4718   return builder_.Finish();
4719 }
4720
4721 struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4722 {
4723   bool Verify(flatbuffers::Verifier &verifier) const
4724   {
4725     return VerifyTableStart(verifier) && verifier.EndTable();
4726   }
4727 };
4728
4729 struct CosOptionsBuilder
4730 {
4731   flatbuffers::FlatBufferBuilder &fbb_;
4732   flatbuffers::uoffset_t start_;
4733   explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4734   {
4735     start_ = fbb_.StartTable();
4736   }
4737   CosOptionsBuilder &operator=(const CosOptionsBuilder &);
4738   flatbuffers::Offset<CosOptions> Finish()
4739   {
4740     const auto end = fbb_.EndTable(start_);
4741     auto o = flatbuffers::Offset<CosOptions>(end);
4742     return o;
4743   }
4744 };
4745
4746 inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb)
4747 {
4748   CosOptionsBuilder builder_(_fbb);
4749   return builder_.Finish();
4750 }
4751
4752 struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4753 {
4754   enum
4755   {
4756     VT_KEEP_DIMS = 4
4757   };
4758   bool keep_dims() const { return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; }
4759   bool Verify(flatbuffers::Verifier &verifier) const
4760   {
4761     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
4762            verifier.EndTable();
4763   }
4764 };
4765
4766 struct ReducerOptionsBuilder
4767 {
4768   flatbuffers::FlatBufferBuilder &fbb_;
4769   flatbuffers::uoffset_t start_;
4770   void add_keep_dims(bool keep_dims)
4771   {
4772     fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
4773   }
4774   explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4775   {
4776     start_ = fbb_.StartTable();
4777   }
4778   ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &);
4779   flatbuffers::Offset<ReducerOptions> Finish()
4780   {
4781     const auto end = fbb_.EndTable(start_);
4782     auto o = flatbuffers::Offset<ReducerOptions>(end);
4783     return o;
4784   }
4785 };
4786
4787 inline flatbuffers::Offset<ReducerOptions>
4788 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false)
4789 {
4790   ReducerOptionsBuilder builder_(_fbb);
4791   builder_.add_keep_dims(keep_dims);
4792   return builder_.Finish();
4793 }
4794
4795 struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4796 {
4797   enum
4798   {
4799     VT_SQUEEZE_DIMS = 4
4800   };
4801   const flatbuffers::Vector<int32_t> *squeeze_dims() const
4802   {
4803     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
4804   }
4805   bool Verify(flatbuffers::Verifier &verifier) const
4806   {
4807     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
4808            verifier.VerifyVector(squeeze_dims()) && verifier.EndTable();
4809   }
4810 };
4811
4812 struct SqueezeOptionsBuilder
4813 {
4814   flatbuffers::FlatBufferBuilder &fbb_;
4815   flatbuffers::uoffset_t start_;
4816   void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims)
4817   {
4818     fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
4819   }
4820   explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4821   {
4822     start_ = fbb_.StartTable();
4823   }
4824   SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
4825   flatbuffers::Offset<SqueezeOptions> Finish()
4826   {
4827     const auto end = fbb_.EndTable(start_);
4828     auto o = flatbuffers::Offset<SqueezeOptions>(end);
4829     return o;
4830   }
4831 };
4832
4833 inline flatbuffers::Offset<SqueezeOptions>
4834 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb,
4835                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0)
4836 {
4837   SqueezeOptionsBuilder builder_(_fbb);
4838   builder_.add_squeeze_dims(squeeze_dims);
4839   return builder_.Finish();
4840 }
4841
4842 inline flatbuffers::Offset<SqueezeOptions>
4843 CreateSqueezeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
4844                            const std::vector<int32_t> *squeeze_dims = nullptr)
4845 {
4846   return onert_tflite::CreateSqueezeOptions(
4847       _fbb, squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0);
4848 }
4849
4850 struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4851 {
4852   enum
4853   {
4854     VT_NUM_SPLITS = 4
4855   };
4856   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
4857   bool Verify(flatbuffers::Verifier &verifier) const
4858   {
4859     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
4860            verifier.EndTable();
4861   }
4862 };
4863
4864 struct SplitOptionsBuilder
4865 {
4866   flatbuffers::FlatBufferBuilder &fbb_;
4867   flatbuffers::uoffset_t start_;
4868   void add_num_splits(int32_t num_splits)
4869   {
4870     fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
4871   }
4872   explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4873   {
4874     start_ = fbb_.StartTable();
4875   }
4876   SplitOptionsBuilder &operator=(const SplitOptionsBuilder &);
4877   flatbuffers::Offset<SplitOptions> Finish()
4878   {
4879     const auto end = fbb_.EndTable(start_);
4880     auto o = flatbuffers::Offset<SplitOptions>(end);
4881     return o;
4882   }
4883 };
4884
4885 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb,
4886                                                             int32_t num_splits = 0)
4887 {
4888   SplitOptionsBuilder builder_(_fbb);
4889   builder_.add_num_splits(num_splits);
4890   return builder_.Finish();
4891 }
4892
4893 struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4894 {
4895   enum
4896   {
4897     VT_NUM_SPLITS = 4
4898   };
4899   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
4900   bool Verify(flatbuffers::Verifier &verifier) const
4901   {
4902     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
4903            verifier.EndTable();
4904   }
4905 };
4906
4907 struct SplitVOptionsBuilder
4908 {
4909   flatbuffers::FlatBufferBuilder &fbb_;
4910   flatbuffers::uoffset_t start_;
4911   void add_num_splits(int32_t num_splits)
4912   {
4913     fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
4914   }
4915   explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4916   {
4917     start_ = fbb_.StartTable();
4918   }
4919   SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &);
4920   flatbuffers::Offset<SplitVOptions> Finish()
4921   {
4922     const auto end = fbb_.EndTable(start_);
4923     auto o = flatbuffers::Offset<SplitVOptions>(end);
4924     return o;
4925   }
4926 };
4927
4928 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb,
4929                                                               int32_t num_splits = 0)
4930 {
4931   SplitVOptionsBuilder builder_(_fbb);
4932   builder_.add_num_splits(num_splits);
4933   return builder_.Finish();
4934 }
4935
4936 struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4937 {
4938   enum
4939   {
4940     VT_BEGIN_MASK = 4,
4941     VT_END_MASK = 6,
4942     VT_ELLIPSIS_MASK = 8,
4943     VT_NEW_AXIS_MASK = 10,
4944     VT_SHRINK_AXIS_MASK = 12
4945   };
4946   int32_t begin_mask() const { return GetField<int32_t>(VT_BEGIN_MASK, 0); }
4947   int32_t end_mask() const { return GetField<int32_t>(VT_END_MASK, 0); }
4948   int32_t ellipsis_mask() const { return GetField<int32_t>(VT_ELLIPSIS_MASK, 0); }
4949   int32_t new_axis_mask() const { return GetField<int32_t>(VT_NEW_AXIS_MASK, 0); }
4950   int32_t shrink_axis_mask() const { return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0); }
4951   bool Verify(flatbuffers::Verifier &verifier) const
4952   {
4953     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
4954            VerifyField<int32_t>(verifier, VT_END_MASK) &&
4955            VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
4956            VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
4957            VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) && verifier.EndTable();
4958   }
4959 };
4960
4961 struct StridedSliceOptionsBuilder
4962 {
4963   flatbuffers::FlatBufferBuilder &fbb_;
4964   flatbuffers::uoffset_t start_;
4965   void add_begin_mask(int32_t begin_mask)
4966   {
4967     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
4968   }
4969   void add_end_mask(int32_t end_mask)
4970   {
4971     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
4972   }
4973   void add_ellipsis_mask(int32_t ellipsis_mask)
4974   {
4975     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
4976   }
4977   void add_new_axis_mask(int32_t new_axis_mask)
4978   {
4979     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
4980   }
4981   void add_shrink_axis_mask(int32_t shrink_axis_mask)
4982   {
4983     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
4984   }
4985   explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4986   {
4987     start_ = fbb_.StartTable();
4988   }
4989   StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
4990   flatbuffers::Offset<StridedSliceOptions> Finish()
4991   {
4992     const auto end = fbb_.EndTable(start_);
4993     auto o = flatbuffers::Offset<StridedSliceOptions>(end);
4994     return o;
4995   }
4996 };
4997
4998 inline flatbuffers::Offset<StridedSliceOptions>
4999 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0,
5000                           int32_t end_mask = 0, int32_t ellipsis_mask = 0,
5001                           int32_t new_axis_mask = 0, int32_t shrink_axis_mask = 0)
5002 {
5003   StridedSliceOptionsBuilder builder_(_fbb);
5004   builder_.add_shrink_axis_mask(shrink_axis_mask);
5005   builder_.add_new_axis_mask(new_axis_mask);
5006   builder_.add_ellipsis_mask(ellipsis_mask);
5007   builder_.add_end_mask(end_mask);
5008   builder_.add_begin_mask(begin_mask);
5009   return builder_.Finish();
5010 }
5011
5012 struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5013 {
5014   bool Verify(flatbuffers::Verifier &verifier) const
5015   {
5016     return VerifyTableStart(verifier) && verifier.EndTable();
5017   }
5018 };
5019
5020 struct LogSoftmaxOptionsBuilder
5021 {
5022   flatbuffers::FlatBufferBuilder &fbb_;
5023   flatbuffers::uoffset_t start_;
5024   explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5025   {
5026     start_ = fbb_.StartTable();
5027   }
5028   LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &);
5029   flatbuffers::Offset<LogSoftmaxOptions> Finish()
5030   {
5031     const auto end = fbb_.EndTable(start_);
5032     auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
5033     return o;
5034   }
5035 };
5036
5037 inline flatbuffers::Offset<LogSoftmaxOptions>
5038 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
5039 {
5040   LogSoftmaxOptionsBuilder builder_(_fbb);
5041   return builder_.Finish();
5042 }
5043
5044 struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5045 {
5046   enum
5047   {
5048     VT_IN_DATA_TYPE = 4,
5049     VT_OUT_DATA_TYPE = 6
5050   };
5051   TensorType in_data_type() const
5052   {
5053     return static_cast<TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
5054   }
5055   TensorType out_data_type() const
5056   {
5057     return static_cast<TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
5058   }
5059   bool Verify(flatbuffers::Verifier &verifier) const
5060   {
5061     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
5062            VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) && verifier.EndTable();
5063   }
5064 };
5065
5066 struct CastOptionsBuilder
5067 {
5068   flatbuffers::FlatBufferBuilder &fbb_;
5069   flatbuffers::uoffset_t start_;
5070   void add_in_data_type(TensorType in_data_type)
5071   {
5072     fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
5073   }
5074   void add_out_data_type(TensorType out_data_type)
5075   {
5076     fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
5077   }
5078   explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5079   {
5080     start_ = fbb_.StartTable();
5081   }
5082   CastOptionsBuilder &operator=(const CastOptionsBuilder &);
5083   flatbuffers::Offset<CastOptions> Finish()
5084   {
5085     const auto end = fbb_.EndTable(start_);
5086     auto o = flatbuffers::Offset<CastOptions>(end);
5087     return o;
5088   }
5089 };
5090
5091 inline flatbuffers::Offset<CastOptions>
5092 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb,
5093                   TensorType in_data_type = TensorType_FLOAT32,
5094                   TensorType out_data_type = TensorType_FLOAT32)
5095 {
5096   CastOptionsBuilder builder_(_fbb);
5097   builder_.add_out_data_type(out_data_type);
5098   builder_.add_in_data_type(in_data_type);
5099   return builder_.Finish();
5100 }
5101
5102 struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5103 {
5104   bool Verify(flatbuffers::Verifier &verifier) const
5105   {
5106     return VerifyTableStart(verifier) && verifier.EndTable();
5107   }
5108 };
5109
5110 struct DequantizeOptionsBuilder
5111 {
5112   flatbuffers::FlatBufferBuilder &fbb_;
5113   flatbuffers::uoffset_t start_;
5114   explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5115   {
5116     start_ = fbb_.StartTable();
5117   }
5118   DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &);
5119   flatbuffers::Offset<DequantizeOptions> Finish()
5120   {
5121     const auto end = fbb_.EndTable(start_);
5122     auto o = flatbuffers::Offset<DequantizeOptions>(end);
5123     return o;
5124   }
5125 };
5126
5127 inline flatbuffers::Offset<DequantizeOptions>
5128 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
5129 {
5130   DequantizeOptionsBuilder builder_(_fbb);
5131   return builder_.Finish();
5132 }
5133
5134 struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5135 {
5136   bool Verify(flatbuffers::Verifier &verifier) const
5137   {
5138     return VerifyTableStart(verifier) && verifier.EndTable();
5139   }
5140 };
5141
5142 struct MaximumMinimumOptionsBuilder
5143 {
5144   flatbuffers::FlatBufferBuilder &fbb_;
5145   flatbuffers::uoffset_t start_;
5146   explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5147   {
5148     start_ = fbb_.StartTable();
5149   }
5150   MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &);
5151   flatbuffers::Offset<MaximumMinimumOptions> Finish()
5152   {
5153     const auto end = fbb_.EndTable(start_);
5154     auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
5155     return o;
5156   }
5157 };
5158
5159 inline flatbuffers::Offset<MaximumMinimumOptions>
5160 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb)
5161 {
5162   MaximumMinimumOptionsBuilder builder_(_fbb);
5163   return builder_.Finish();
5164 }
5165
5166 struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5167 {
5168   bool Verify(flatbuffers::Verifier &verifier) const
5169   {
5170     return VerifyTableStart(verifier) && verifier.EndTable();
5171   }
5172 };
5173
5174 struct TileOptionsBuilder
5175 {
5176   flatbuffers::FlatBufferBuilder &fbb_;
5177   flatbuffers::uoffset_t start_;
5178   explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5179   {
5180     start_ = fbb_.StartTable();
5181   }
5182   TileOptionsBuilder &operator=(const TileOptionsBuilder &);
5183   flatbuffers::Offset<TileOptions> Finish()
5184   {
5185     const auto end = fbb_.EndTable(start_);
5186     auto o = flatbuffers::Offset<TileOptions>(end);
5187     return o;
5188   }
5189 };
5190
5191 inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb)
5192 {
5193   TileOptionsBuilder builder_(_fbb);
5194   return builder_.Finish();
5195 }
5196
5197 struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5198 {
5199   enum
5200   {
5201     VT_OUTPUT_TYPE = 4
5202   };
5203   TensorType output_type() const
5204   {
5205     return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
5206   }
5207   bool Verify(flatbuffers::Verifier &verifier) const
5208   {
5209     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
5210            verifier.EndTable();
5211   }
5212 };
5213
5214 struct ArgMaxOptionsBuilder
5215 {
5216   flatbuffers::FlatBufferBuilder &fbb_;
5217   flatbuffers::uoffset_t start_;
5218   void add_output_type(TensorType output_type)
5219   {
5220     fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
5221   }
5222   explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5223   {
5224     start_ = fbb_.StartTable();
5225   }
5226   ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &);
5227   flatbuffers::Offset<ArgMaxOptions> Finish()
5228   {
5229     const auto end = fbb_.EndTable(start_);
5230     auto o = flatbuffers::Offset<ArgMaxOptions>(end);
5231     return o;
5232   }
5233 };
5234
5235 inline flatbuffers::Offset<ArgMaxOptions>
5236 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb,
5237                     TensorType output_type = TensorType_FLOAT32)
5238 {
5239   ArgMaxOptionsBuilder builder_(_fbb);
5240   builder_.add_output_type(output_type);
5241   return builder_.Finish();
5242 }
5243
5244 struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5245 {
5246   enum
5247   {
5248     VT_OUTPUT_TYPE = 4
5249   };
5250   TensorType output_type() const
5251   {
5252     return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
5253   }
5254   bool Verify(flatbuffers::Verifier &verifier) const
5255   {
5256     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
5257            verifier.EndTable();
5258   }
5259 };
5260
5261 struct ArgMinOptionsBuilder
5262 {
5263   flatbuffers::FlatBufferBuilder &fbb_;
5264   flatbuffers::uoffset_t start_;
5265   void add_output_type(TensorType output_type)
5266   {
5267     fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
5268   }
5269   explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5270   {
5271     start_ = fbb_.StartTable();
5272   }
5273   ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &);
5274   flatbuffers::Offset<ArgMinOptions> Finish()
5275   {
5276     const auto end = fbb_.EndTable(start_);
5277     auto o = flatbuffers::Offset<ArgMinOptions>(end);
5278     return o;
5279   }
5280 };
5281
5282 inline flatbuffers::Offset<ArgMinOptions>
5283 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb,
5284                     TensorType output_type = TensorType_FLOAT32)
5285 {
5286   ArgMinOptionsBuilder builder_(_fbb);
5287   builder_.add_output_type(output_type);
5288   return builder_.Finish();
5289 }
5290
5291 struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5292 {
5293   bool Verify(flatbuffers::Verifier &verifier) const
5294   {
5295     return VerifyTableStart(verifier) && verifier.EndTable();
5296   }
5297 };
5298
5299 struct GreaterOptionsBuilder
5300 {
5301   flatbuffers::FlatBufferBuilder &fbb_;
5302   flatbuffers::uoffset_t start_;
5303   explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5304   {
5305     start_ = fbb_.StartTable();
5306   }
5307   GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &);
5308   flatbuffers::Offset<GreaterOptions> Finish()
5309   {
5310     const auto end = fbb_.EndTable(start_);
5311     auto o = flatbuffers::Offset<GreaterOptions>(end);
5312     return o;
5313   }
5314 };
5315
5316 inline flatbuffers::Offset<GreaterOptions>
5317 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb)
5318 {
5319   GreaterOptionsBuilder builder_(_fbb);
5320   return builder_.Finish();
5321 }
5322
5323 struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5324 {
5325   bool Verify(flatbuffers::Verifier &verifier) const
5326   {
5327     return VerifyTableStart(verifier) && verifier.EndTable();
5328   }
5329 };
5330
5331 struct GreaterEqualOptionsBuilder
5332 {
5333   flatbuffers::FlatBufferBuilder &fbb_;
5334   flatbuffers::uoffset_t start_;
5335   explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5336   {
5337     start_ = fbb_.StartTable();
5338   }
5339   GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &);
5340   flatbuffers::Offset<GreaterEqualOptions> Finish()
5341   {
5342     const auto end = fbb_.EndTable(start_);
5343     auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
5344     return o;
5345   }
5346 };
5347
5348 inline flatbuffers::Offset<GreaterEqualOptions>
5349 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
5350 {
5351   GreaterEqualOptionsBuilder builder_(_fbb);
5352   return builder_.Finish();
5353 }
5354
5355 struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5356 {
5357   bool Verify(flatbuffers::Verifier &verifier) const
5358   {
5359     return VerifyTableStart(verifier) && verifier.EndTable();
5360   }
5361 };
5362
5363 struct LessOptionsBuilder
5364 {
5365   flatbuffers::FlatBufferBuilder &fbb_;
5366   flatbuffers::uoffset_t start_;
5367   explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5368   {
5369     start_ = fbb_.StartTable();
5370   }
5371   LessOptionsBuilder &operator=(const LessOptionsBuilder &);
5372   flatbuffers::Offset<LessOptions> Finish()
5373   {
5374     const auto end = fbb_.EndTable(start_);
5375     auto o = flatbuffers::Offset<LessOptions>(end);
5376     return o;
5377   }
5378 };
5379
5380 inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb)
5381 {
5382   LessOptionsBuilder builder_(_fbb);
5383   return builder_.Finish();
5384 }
5385
5386 struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5387 {
5388   bool Verify(flatbuffers::Verifier &verifier) const
5389   {
5390     return VerifyTableStart(verifier) && verifier.EndTable();
5391   }
5392 };
5393
5394 struct LessEqualOptionsBuilder
5395 {
5396   flatbuffers::FlatBufferBuilder &fbb_;
5397   flatbuffers::uoffset_t start_;
5398   explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5399   {
5400     start_ = fbb_.StartTable();
5401   }
5402   LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &);
5403   flatbuffers::Offset<LessEqualOptions> Finish()
5404   {
5405     const auto end = fbb_.EndTable(start_);
5406     auto o = flatbuffers::Offset<LessEqualOptions>(end);
5407     return o;
5408   }
5409 };
5410
5411 inline flatbuffers::Offset<LessEqualOptions>
5412 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
5413 {
5414   LessEqualOptionsBuilder builder_(_fbb);
5415   return builder_.Finish();
5416 }
5417
5418 struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5419 {
5420   bool Verify(flatbuffers::Verifier &verifier) const
5421   {
5422     return VerifyTableStart(verifier) && verifier.EndTable();
5423   }
5424 };
5425
5426 struct NegOptionsBuilder
5427 {
5428   flatbuffers::FlatBufferBuilder &fbb_;
5429   flatbuffers::uoffset_t start_;
5430   explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5431   {
5432     start_ = fbb_.StartTable();
5433   }
5434   NegOptionsBuilder &operator=(const NegOptionsBuilder &);
5435   flatbuffers::Offset<NegOptions> Finish()
5436   {
5437     const auto end = fbb_.EndTable(start_);
5438     auto o = flatbuffers::Offset<NegOptions>(end);
5439     return o;
5440   }
5441 };
5442
5443 inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb)
5444 {
5445   NegOptionsBuilder builder_(_fbb);
5446   return builder_.Finish();
5447 }
5448
5449 struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5450 {
5451   bool Verify(flatbuffers::Verifier &verifier) const
5452   {
5453     return VerifyTableStart(verifier) && verifier.EndTable();
5454   }
5455 };
5456
5457 struct SelectOptionsBuilder
5458 {
5459   flatbuffers::FlatBufferBuilder &fbb_;
5460   flatbuffers::uoffset_t start_;
5461   explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5462   {
5463     start_ = fbb_.StartTable();
5464   }
5465   SelectOptionsBuilder &operator=(const SelectOptionsBuilder &);
5466   flatbuffers::Offset<SelectOptions> Finish()
5467   {
5468     const auto end = fbb_.EndTable(start_);
5469     auto o = flatbuffers::Offset<SelectOptions>(end);
5470     return o;
5471   }
5472 };
5473
5474 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb)
5475 {
5476   SelectOptionsBuilder builder_(_fbb);
5477   return builder_.Finish();
5478 }
5479
5480 struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5481 {
5482   bool Verify(flatbuffers::Verifier &verifier) const
5483   {
5484     return VerifyTableStart(verifier) && verifier.EndTable();
5485   }
5486 };
5487
5488 struct SliceOptionsBuilder
5489 {
5490   flatbuffers::FlatBufferBuilder &fbb_;
5491   flatbuffers::uoffset_t start_;
5492   explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5493   {
5494     start_ = fbb_.StartTable();
5495   }
5496   SliceOptionsBuilder &operator=(const SliceOptionsBuilder &);
5497   flatbuffers::Offset<SliceOptions> Finish()
5498   {
5499     const auto end = fbb_.EndTable(start_);
5500     auto o = flatbuffers::Offset<SliceOptions>(end);
5501     return o;
5502   }
5503 };
5504
5505 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
5506 {
5507   SliceOptionsBuilder builder_(_fbb);
5508   return builder_.Finish();
5509 }
5510
5511 struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5512 {
5513   enum
5514   {
5515     VT_PADDING = 4,
5516     VT_STRIDE_W = 6,
5517     VT_STRIDE_H = 8
5518   };
5519   Padding padding() const { return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); }
5520   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
5521   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
5522   bool Verify(flatbuffers::Verifier &verifier) const
5523   {
5524     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
5525            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
5526            VerifyField<int32_t>(verifier, VT_STRIDE_H) && verifier.EndTable();
5527   }
5528 };
5529
5530 struct TransposeConvOptionsBuilder
5531 {
5532   flatbuffers::FlatBufferBuilder &fbb_;
5533   flatbuffers::uoffset_t start_;
5534   void add_padding(Padding padding)
5535   {
5536     fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5537   }
5538   void add_stride_w(int32_t stride_w)
5539   {
5540     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
5541   }
5542   void add_stride_h(int32_t stride_h)
5543   {
5544     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
5545   }
5546   explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5547   {
5548     start_ = fbb_.StartTable();
5549   }
5550   TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &);
5551   flatbuffers::Offset<TransposeConvOptions> Finish()
5552   {
5553     const auto end = fbb_.EndTable(start_);
5554     auto o = flatbuffers::Offset<TransposeConvOptions>(end);
5555     return o;
5556   }
5557 };
5558
5559 inline flatbuffers::Offset<TransposeConvOptions>
5560 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, Padding padding = Padding_SAME,
5561                            int32_t stride_w = 0, int32_t stride_h = 0)
5562 {
5563   TransposeConvOptionsBuilder builder_(_fbb);
5564   builder_.add_stride_h(stride_h);
5565   builder_.add_stride_w(stride_w);
5566   builder_.add_padding(padding);
5567   return builder_.Finish();
5568 }
5569
5570 struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5571 {
5572   bool Verify(flatbuffers::Verifier &verifier) const
5573   {
5574     return VerifyTableStart(verifier) && verifier.EndTable();
5575   }
5576 };
5577
5578 struct ExpandDimsOptionsBuilder
5579 {
5580   flatbuffers::FlatBufferBuilder &fbb_;
5581   flatbuffers::uoffset_t start_;
5582   explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5583   {
5584     start_ = fbb_.StartTable();
5585   }
5586   ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &);
5587   flatbuffers::Offset<ExpandDimsOptions> Finish()
5588   {
5589     const auto end = fbb_.EndTable(start_);
5590     auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
5591     return o;
5592   }
5593 };
5594
5595 inline flatbuffers::Offset<ExpandDimsOptions>
5596 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb)
5597 {
5598   ExpandDimsOptionsBuilder builder_(_fbb);
5599   return builder_.Finish();
5600 }
5601
5602 struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5603 {
5604   enum
5605   {
5606     VT_VALIDATE_INDICES = 4
5607   };
5608   bool validate_indices() const { return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0; }
5609   bool Verify(flatbuffers::Verifier &verifier) const
5610   {
5611     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
5612            verifier.EndTable();
5613   }
5614 };
5615
5616 struct SparseToDenseOptionsBuilder
5617 {
5618   flatbuffers::FlatBufferBuilder &fbb_;
5619   flatbuffers::uoffset_t start_;
5620   void add_validate_indices(bool validate_indices)
5621   {
5622     fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES,
5623                              static_cast<uint8_t>(validate_indices), 0);
5624   }
5625   explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5626   {
5627     start_ = fbb_.StartTable();
5628   }
5629   SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &);
5630   flatbuffers::Offset<SparseToDenseOptions> Finish()
5631   {
5632     const auto end = fbb_.EndTable(start_);
5633     auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
5634     return o;
5635   }
5636 };
5637
5638 inline flatbuffers::Offset<SparseToDenseOptions>
5639 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices = false)
5640 {
5641   SparseToDenseOptionsBuilder builder_(_fbb);
5642   builder_.add_validate_indices(validate_indices);
5643   return builder_.Finish();
5644 }
5645
5646 struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5647 {
5648   bool Verify(flatbuffers::Verifier &verifier) const
5649   {
5650     return VerifyTableStart(verifier) && verifier.EndTable();
5651   }
5652 };
5653
5654 struct EqualOptionsBuilder
5655 {
5656   flatbuffers::FlatBufferBuilder &fbb_;
5657   flatbuffers::uoffset_t start_;
5658   explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5659   {
5660     start_ = fbb_.StartTable();
5661   }
5662   EqualOptionsBuilder &operator=(const EqualOptionsBuilder &);
5663   flatbuffers::Offset<EqualOptions> Finish()
5664   {
5665     const auto end = fbb_.EndTable(start_);
5666     auto o = flatbuffers::Offset<EqualOptions>(end);
5667     return o;
5668   }
5669 };
5670
5671 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
5672 {
5673   EqualOptionsBuilder builder_(_fbb);
5674   return builder_.Finish();
5675 }
5676
5677 struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5678 {
5679   bool Verify(flatbuffers::Verifier &verifier) const
5680   {
5681     return VerifyTableStart(verifier) && verifier.EndTable();
5682   }
5683 };
5684
5685 struct NotEqualOptionsBuilder
5686 {
5687   flatbuffers::FlatBufferBuilder &fbb_;
5688   flatbuffers::uoffset_t start_;
5689   explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5690   {
5691     start_ = fbb_.StartTable();
5692   }
5693   NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &);
5694   flatbuffers::Offset<NotEqualOptions> Finish()
5695   {
5696     const auto end = fbb_.EndTable(start_);
5697     auto o = flatbuffers::Offset<NotEqualOptions>(end);
5698     return o;
5699   }
5700 };
5701
5702 inline flatbuffers::Offset<NotEqualOptions>
5703 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
5704 {
5705   NotEqualOptionsBuilder builder_(_fbb);
5706   return builder_.Finish();
5707 }
5708
5709 struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5710 {
5711   enum
5712   {
5713     VT_OUT_TYPE = 4
5714   };
5715   TensorType out_type() const { return static_cast<TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0)); }
5716   bool Verify(flatbuffers::Verifier &verifier) const
5717   {
5718     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
5719            verifier.EndTable();
5720   }
5721 };
5722
5723 struct ShapeOptionsBuilder
5724 {
5725   flatbuffers::FlatBufferBuilder &fbb_;
5726   flatbuffers::uoffset_t start_;
5727   void add_out_type(TensorType out_type)
5728   {
5729     fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
5730   }
5731   explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5732   {
5733     start_ = fbb_.StartTable();
5734   }
5735   ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &);
5736   flatbuffers::Offset<ShapeOptions> Finish()
5737   {
5738     const auto end = fbb_.EndTable(start_);
5739     auto o = flatbuffers::Offset<ShapeOptions>(end);
5740     return o;
5741   }
5742 };
5743
5744 inline flatbuffers::Offset<ShapeOptions>
5745 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, TensorType out_type = TensorType_FLOAT32)
5746 {
5747   ShapeOptionsBuilder builder_(_fbb);
5748   builder_.add_out_type(out_type);
5749   return builder_.Finish();
5750 }
5751
5752 struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5753 {
5754   bool Verify(flatbuffers::Verifier &verifier) const
5755   {
5756     return VerifyTableStart(verifier) && verifier.EndTable();
5757   }
5758 };
5759
5760 struct RankOptionsBuilder
5761 {
5762   flatbuffers::FlatBufferBuilder &fbb_;
5763   flatbuffers::uoffset_t start_;
5764   explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5765   {
5766     start_ = fbb_.StartTable();
5767   }
5768   RankOptionsBuilder &operator=(const RankOptionsBuilder &);
5769   flatbuffers::Offset<RankOptions> Finish()
5770   {
5771     const auto end = fbb_.EndTable(start_);
5772     auto o = flatbuffers::Offset<RankOptions>(end);
5773     return o;
5774   }
5775 };
5776
5777 inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb)
5778 {
5779   RankOptionsBuilder builder_(_fbb);
5780   return builder_.Finish();
5781 }
5782
5783 struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5784 {
5785   bool Verify(flatbuffers::Verifier &verifier) const
5786   {
5787     return VerifyTableStart(verifier) && verifier.EndTable();
5788   }
5789 };
5790
5791 struct PowOptionsBuilder
5792 {
5793   flatbuffers::FlatBufferBuilder &fbb_;
5794   flatbuffers::uoffset_t start_;
5795   explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5796   {
5797     start_ = fbb_.StartTable();
5798   }
5799   PowOptionsBuilder &operator=(const PowOptionsBuilder &);
5800   flatbuffers::Offset<PowOptions> Finish()
5801   {
5802     const auto end = fbb_.EndTable(start_);
5803     auto o = flatbuffers::Offset<PowOptions>(end);
5804     return o;
5805   }
5806 };
5807
5808 inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb)
5809 {
5810   PowOptionsBuilder builder_(_fbb);
5811   return builder_.Finish();
5812 }
5813
5814 struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5815 {
5816   enum
5817   {
5818     VT_MIN = 4,
5819     VT_MAX = 6,
5820     VT_NUM_BITS = 8,
5821     VT_NARROW_RANGE = 10
5822   };
5823   float min() const { return GetField<float>(VT_MIN, 0.0f); }
5824   float max() const { return GetField<float>(VT_MAX, 0.0f); }
5825   int32_t num_bits() const { return GetField<int32_t>(VT_NUM_BITS, 0); }
5826   bool narrow_range() const { return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0; }
5827   bool Verify(flatbuffers::Verifier &verifier) const
5828   {
5829     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_MIN) &&
5830            VerifyField<float>(verifier, VT_MAX) && VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
5831            VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) && verifier.EndTable();
5832   }
5833 };
5834
5835 struct FakeQuantOptionsBuilder
5836 {
5837   flatbuffers::FlatBufferBuilder &fbb_;
5838   flatbuffers::uoffset_t start_;
5839   void add_min(float min) { fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f); }
5840   void add_max(float max) { fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f); }
5841   void add_num_bits(int32_t num_bits)
5842   {
5843     fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
5844   }
5845   void add_narrow_range(bool narrow_range)
5846   {
5847     fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range),
5848                              0);
5849   }
5850   explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5851   {
5852     start_ = fbb_.StartTable();
5853   }
5854   FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &);
5855   flatbuffers::Offset<FakeQuantOptions> Finish()
5856   {
5857     const auto end = fbb_.EndTable(start_);
5858     auto o = flatbuffers::Offset<FakeQuantOptions>(end);
5859     return o;
5860   }
5861 };
5862
5863 inline flatbuffers::Offset<FakeQuantOptions>
5864 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, float min = 0.0f, float max = 0.0f,
5865                        int32_t num_bits = 0, bool narrow_range = false)
5866 {
5867   FakeQuantOptionsBuilder builder_(_fbb);
5868   builder_.add_num_bits(num_bits);
5869   builder_.add_max(max);
5870   builder_.add_min(min);
5871   builder_.add_narrow_range(narrow_range);
5872   return builder_.Finish();
5873 }
5874
5875 struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5876 {
5877   enum
5878   {
5879     VT_VALUES_COUNT = 4,
5880     VT_AXIS = 6
5881   };
5882   int32_t values_count() const { return GetField<int32_t>(VT_VALUES_COUNT, 0); }
5883   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
5884   bool Verify(flatbuffers::Verifier &verifier) const
5885   {
5886     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
5887            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
5888   }
5889 };
5890
5891 struct PackOptionsBuilder
5892 {
5893   flatbuffers::FlatBufferBuilder &fbb_;
5894   flatbuffers::uoffset_t start_;
5895   void add_values_count(int32_t values_count)
5896   {
5897     fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
5898   }
5899   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0); }
5900   explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5901   {
5902     start_ = fbb_.StartTable();
5903   }
5904   PackOptionsBuilder &operator=(const PackOptionsBuilder &);
5905   flatbuffers::Offset<PackOptions> Finish()
5906   {
5907     const auto end = fbb_.EndTable(start_);
5908     auto o = flatbuffers::Offset<PackOptions>(end);
5909     return o;
5910   }
5911 };
5912
5913 inline flatbuffers::Offset<PackOptions>
5914 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count = 0, int32_t axis = 0)
5915 {
5916   PackOptionsBuilder builder_(_fbb);
5917   builder_.add_axis(axis);
5918   builder_.add_values_count(values_count);
5919   return builder_.Finish();
5920 }
5921
5922 struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5923 {
5924   bool Verify(flatbuffers::Verifier &verifier) const
5925   {
5926     return VerifyTableStart(verifier) && verifier.EndTable();
5927   }
5928 };
5929
5930 struct LogicalOrOptionsBuilder
5931 {
5932   flatbuffers::FlatBufferBuilder &fbb_;
5933   flatbuffers::uoffset_t start_;
5934   explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5935   {
5936     start_ = fbb_.StartTable();
5937   }
5938   LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &);
5939   flatbuffers::Offset<LogicalOrOptions> Finish()
5940   {
5941     const auto end = fbb_.EndTable(start_);
5942     auto o = flatbuffers::Offset<LogicalOrOptions>(end);
5943     return o;
5944   }
5945 };
5946
5947 inline flatbuffers::Offset<LogicalOrOptions>
5948 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb)
5949 {
5950   LogicalOrOptionsBuilder builder_(_fbb);
5951   return builder_.Finish();
5952 }
5953
5954 struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5955 {
5956   enum
5957   {
5958     VT_AXIS = 4
5959   };
5960   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
5961   bool Verify(flatbuffers::Verifier &verifier) const
5962   {
5963     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
5964            verifier.EndTable();
5965   }
5966 };
5967
5968 struct OneHotOptionsBuilder
5969 {
5970   flatbuffers::FlatBufferBuilder &fbb_;
5971   flatbuffers::uoffset_t start_;
5972   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0); }
5973   explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5974   {
5975     start_ = fbb_.StartTable();
5976   }
5977   OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &);
5978   flatbuffers::Offset<OneHotOptions> Finish()
5979   {
5980     const auto end = fbb_.EndTable(start_);
5981     auto o = flatbuffers::Offset<OneHotOptions>(end);
5982     return o;
5983   }
5984 };
5985
5986 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb,
5987                                                               int32_t axis = 0)
5988 {
5989   OneHotOptionsBuilder builder_(_fbb);
5990   builder_.add_axis(axis);
5991   return builder_.Finish();
5992 }
5993
5994 struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5995 {
5996   bool Verify(flatbuffers::Verifier &verifier) const
5997   {
5998     return VerifyTableStart(verifier) && verifier.EndTable();
5999   }
6000 };
6001
6002 struct AbsOptionsBuilder
6003 {
6004   flatbuffers::FlatBufferBuilder &fbb_;
6005   flatbuffers::uoffset_t start_;
6006   explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6007   {
6008     start_ = fbb_.StartTable();
6009   }
6010   AbsOptionsBuilder &operator=(const AbsOptionsBuilder &);
6011   flatbuffers::Offset<AbsOptions> Finish()
6012   {
6013     const auto end = fbb_.EndTable(start_);
6014     auto o = flatbuffers::Offset<AbsOptions>(end);
6015     return o;
6016   }
6017 };
6018
6019 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb)
6020 {
6021   AbsOptionsBuilder builder_(_fbb);
6022   return builder_.Finish();
6023 }
6024
6025 struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6026 {
6027   bool Verify(flatbuffers::Verifier &verifier) const
6028   {
6029     return VerifyTableStart(verifier) && verifier.EndTable();
6030   }
6031 };
6032
6033 struct HardSwishOptionsBuilder
6034 {
6035   flatbuffers::FlatBufferBuilder &fbb_;
6036   flatbuffers::uoffset_t start_;
6037   explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6038   {
6039     start_ = fbb_.StartTable();
6040   }
6041   HardSwishOptionsBuilder &operator=(const HardSwishOptionsBuilder &);
6042   flatbuffers::Offset<HardSwishOptions> Finish()
6043   {
6044     const auto end = fbb_.EndTable(start_);
6045     auto o = flatbuffers::Offset<HardSwishOptions>(end);
6046     return o;
6047   }
6048 };
6049
6050 inline flatbuffers::Offset<HardSwishOptions>
6051 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb)
6052 {
6053   HardSwishOptionsBuilder builder_(_fbb);
6054   return builder_.Finish();
6055 }
6056
6057 struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6058 {
6059   bool Verify(flatbuffers::Verifier &verifier) const
6060   {
6061     return VerifyTableStart(verifier) && verifier.EndTable();
6062   }
6063 };
6064
6065 struct LogicalAndOptionsBuilder
6066 {
6067   flatbuffers::FlatBufferBuilder &fbb_;
6068   flatbuffers::uoffset_t start_;
6069   explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6070   {
6071     start_ = fbb_.StartTable();
6072   }
6073   LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &);
6074   flatbuffers::Offset<LogicalAndOptions> Finish()
6075   {
6076     const auto end = fbb_.EndTable(start_);
6077     auto o = flatbuffers::Offset<LogicalAndOptions>(end);
6078     return o;
6079   }
6080 };
6081
6082 inline flatbuffers::Offset<LogicalAndOptions>
6083 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb)
6084 {
6085   LogicalAndOptionsBuilder builder_(_fbb);
6086   return builder_.Finish();
6087 }
6088
6089 struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6090 {
6091   bool Verify(flatbuffers::Verifier &verifier) const
6092   {
6093     return VerifyTableStart(verifier) && verifier.EndTable();
6094   }
6095 };
6096
6097 struct LogicalNotOptionsBuilder
6098 {
6099   flatbuffers::FlatBufferBuilder &fbb_;
6100   flatbuffers::uoffset_t start_;
6101   explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6102   {
6103     start_ = fbb_.StartTable();
6104   }
6105   LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &);
6106   flatbuffers::Offset<LogicalNotOptions> Finish()
6107   {
6108     const auto end = fbb_.EndTable(start_);
6109     auto o = flatbuffers::Offset<LogicalNotOptions>(end);
6110     return o;
6111   }
6112 };
6113
6114 inline flatbuffers::Offset<LogicalNotOptions>
6115 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb)
6116 {
6117   LogicalNotOptionsBuilder builder_(_fbb);
6118   return builder_.Finish();
6119 }
6120
6121 struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6122 {
6123   enum
6124   {
6125     VT_NUM = 4,
6126     VT_AXIS = 6
6127   };
6128   int32_t num() const { return GetField<int32_t>(VT_NUM, 0); }
6129   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6130   bool Verify(flatbuffers::Verifier &verifier) const
6131   {
6132     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM) &&
6133            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
6134   }
6135 };
6136
6137 struct UnpackOptionsBuilder
6138 {
6139   flatbuffers::FlatBufferBuilder &fbb_;
6140   flatbuffers::uoffset_t start_;
6141   void add_num(int32_t num) { fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0); }
6142   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0); }
6143   explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6144   {
6145     start_ = fbb_.StartTable();
6146   }
6147   UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &);
6148   flatbuffers::Offset<UnpackOptions> Finish()
6149   {
6150     const auto end = fbb_.EndTable(start_);
6151     auto o = flatbuffers::Offset<UnpackOptions>(end);
6152     return o;
6153   }
6154 };
6155
6156 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb,
6157                                                               int32_t num = 0, int32_t axis = 0)
6158 {
6159   UnpackOptionsBuilder builder_(_fbb);
6160   builder_.add_axis(axis);
6161   builder_.add_num(num);
6162   return builder_.Finish();
6163 }
6164
6165 struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6166 {
6167   bool Verify(flatbuffers::Verifier &verifier) const
6168   {
6169     return VerifyTableStart(verifier) && verifier.EndTable();
6170   }
6171 };
6172
6173 struct FloorDivOptionsBuilder
6174 {
6175   flatbuffers::FlatBufferBuilder &fbb_;
6176   flatbuffers::uoffset_t start_;
6177   explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6178   {
6179     start_ = fbb_.StartTable();
6180   }
6181   FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &);
6182   flatbuffers::Offset<FloorDivOptions> Finish()
6183   {
6184     const auto end = fbb_.EndTable(start_);
6185     auto o = flatbuffers::Offset<FloorDivOptions>(end);
6186     return o;
6187   }
6188 };
6189
6190 inline flatbuffers::Offset<FloorDivOptions>
6191 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb)
6192 {
6193   FloorDivOptionsBuilder builder_(_fbb);
6194   return builder_.Finish();
6195 }
6196
6197 struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6198 {
6199   bool Verify(flatbuffers::Verifier &verifier) const
6200   {
6201     return VerifyTableStart(verifier) && verifier.EndTable();
6202   }
6203 };
6204
6205 struct SquareOptionsBuilder
6206 {
6207   flatbuffers::FlatBufferBuilder &fbb_;
6208   flatbuffers::uoffset_t start_;
6209   explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6210   {
6211     start_ = fbb_.StartTable();
6212   }
6213   SquareOptionsBuilder &operator=(const SquareOptionsBuilder &);
6214   flatbuffers::Offset<SquareOptions> Finish()
6215   {
6216     const auto end = fbb_.EndTable(start_);
6217     auto o = flatbuffers::Offset<SquareOptions>(end);
6218     return o;
6219   }
6220 };
6221
6222 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb)
6223 {
6224   SquareOptionsBuilder builder_(_fbb);
6225   return builder_.Finish();
6226 }
6227
6228 struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6229 {
6230   bool Verify(flatbuffers::Verifier &verifier) const
6231   {
6232     return VerifyTableStart(verifier) && verifier.EndTable();
6233   }
6234 };
6235
6236 struct ZerosLikeOptionsBuilder
6237 {
6238   flatbuffers::FlatBufferBuilder &fbb_;
6239   flatbuffers::uoffset_t start_;
6240   explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6241   {
6242     start_ = fbb_.StartTable();
6243   }
6244   ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &);
6245   flatbuffers::Offset<ZerosLikeOptions> Finish()
6246   {
6247     const auto end = fbb_.EndTable(start_);
6248     auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
6249     return o;
6250   }
6251 };
6252
6253 inline flatbuffers::Offset<ZerosLikeOptions>
6254 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb)
6255 {
6256   ZerosLikeOptionsBuilder builder_(_fbb);
6257   return builder_.Finish();
6258 }
6259
6260 struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6261 {
6262   bool Verify(flatbuffers::Verifier &verifier) const
6263   {
6264     return VerifyTableStart(verifier) && verifier.EndTable();
6265   }
6266 };
6267
6268 struct FillOptionsBuilder
6269 {
6270   flatbuffers::FlatBufferBuilder &fbb_;
6271   flatbuffers::uoffset_t start_;
6272   explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6273   {
6274     start_ = fbb_.StartTable();
6275   }
6276   FillOptionsBuilder &operator=(const FillOptionsBuilder &);
6277   flatbuffers::Offset<FillOptions> Finish()
6278   {
6279     const auto end = fbb_.EndTable(start_);
6280     auto o = flatbuffers::Offset<FillOptions>(end);
6281     return o;
6282   }
6283 };
6284
6285 inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb)
6286 {
6287   FillOptionsBuilder builder_(_fbb);
6288   return builder_.Finish();
6289 }
6290
6291 struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6292 {
6293   bool Verify(flatbuffers::Verifier &verifier) const
6294   {
6295     return VerifyTableStart(verifier) && verifier.EndTable();
6296   }
6297 };
6298
6299 struct FloorModOptionsBuilder
6300 {
6301   flatbuffers::FlatBufferBuilder &fbb_;
6302   flatbuffers::uoffset_t start_;
6303   explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6304   {
6305     start_ = fbb_.StartTable();
6306   }
6307   FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &);
6308   flatbuffers::Offset<FloorModOptions> Finish()
6309   {
6310     const auto end = fbb_.EndTable(start_);
6311     auto o = flatbuffers::Offset<FloorModOptions>(end);
6312     return o;
6313   }
6314 };
6315
6316 inline flatbuffers::Offset<FloorModOptions>
6317 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb)
6318 {
6319   FloorModOptionsBuilder builder_(_fbb);
6320   return builder_.Finish();
6321 }
6322
6323 struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6324 {
6325   bool Verify(flatbuffers::Verifier &verifier) const
6326   {
6327     return VerifyTableStart(verifier) && verifier.EndTable();
6328   }
6329 };
6330
6331 struct RangeOptionsBuilder
6332 {
6333   flatbuffers::FlatBufferBuilder &fbb_;
6334   flatbuffers::uoffset_t start_;
6335   explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6336   {
6337     start_ = fbb_.StartTable();
6338   }
6339   RangeOptionsBuilder &operator=(const RangeOptionsBuilder &);
6340   flatbuffers::Offset<RangeOptions> Finish()
6341   {
6342     const auto end = fbb_.EndTable(start_);
6343     auto o = flatbuffers::Offset<RangeOptions>(end);
6344     return o;
6345   }
6346 };
6347
6348 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb)
6349 {
6350   RangeOptionsBuilder builder_(_fbb);
6351   return builder_.Finish();
6352 }
6353
6354 struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6355 {
6356   enum
6357   {
6358     VT_ALPHA = 4
6359   };
6360   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
6361   bool Verify(flatbuffers::Verifier &verifier) const
6362   {
6363     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_ALPHA) &&
6364            verifier.EndTable();
6365   }
6366 };
6367
6368 struct LeakyReluOptionsBuilder
6369 {
6370   flatbuffers::FlatBufferBuilder &fbb_;
6371   flatbuffers::uoffset_t start_;
6372   void add_alpha(float alpha) { fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); }
6373   explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6374   {
6375     start_ = fbb_.StartTable();
6376   }
6377   LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &);
6378   flatbuffers::Offset<LeakyReluOptions> Finish()
6379   {
6380     const auto end = fbb_.EndTable(start_);
6381     auto o = flatbuffers::Offset<LeakyReluOptions>(end);
6382     return o;
6383   }
6384 };
6385
6386 inline flatbuffers::Offset<LeakyReluOptions>
6387 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, float alpha = 0.0f)
6388 {
6389   LeakyReluOptionsBuilder builder_(_fbb);
6390   builder_.add_alpha(alpha);
6391   return builder_.Finish();
6392 }
6393
6394 struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6395 {
6396   bool Verify(flatbuffers::Verifier &verifier) const
6397   {
6398     return VerifyTableStart(verifier) && verifier.EndTable();
6399   }
6400 };
6401
6402 struct SquaredDifferenceOptionsBuilder
6403 {
6404   flatbuffers::FlatBufferBuilder &fbb_;
6405   flatbuffers::uoffset_t start_;
6406   explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6407   {
6408     start_ = fbb_.StartTable();
6409   }
6410   SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &);
6411   flatbuffers::Offset<SquaredDifferenceOptions> Finish()
6412   {
6413     const auto end = fbb_.EndTable(start_);
6414     auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
6415     return o;
6416   }
6417 };
6418
6419 inline flatbuffers::Offset<SquaredDifferenceOptions>
6420 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb)
6421 {
6422   SquaredDifferenceOptionsBuilder builder_(_fbb);
6423   return builder_.Finish();
6424 }
6425
6426 struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6427 {
6428   enum
6429   {
6430     VT_MODE = 4
6431   };
6432   MirrorPadMode mode() const { return static_cast<MirrorPadMode>(GetField<int8_t>(VT_MODE, 0)); }
6433   bool Verify(flatbuffers::Verifier &verifier) const
6434   {
6435     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_MODE) &&
6436            verifier.EndTable();
6437   }
6438 };
6439
6440 struct MirrorPadOptionsBuilder
6441 {
6442   flatbuffers::FlatBufferBuilder &fbb_;
6443   flatbuffers::uoffset_t start_;
6444   void add_mode(MirrorPadMode mode)
6445   {
6446     fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
6447   }
6448   explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6449   {
6450     start_ = fbb_.StartTable();
6451   }
6452   MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &);
6453   flatbuffers::Offset<MirrorPadOptions> Finish()
6454   {
6455     const auto end = fbb_.EndTable(start_);
6456     auto o = flatbuffers::Offset<MirrorPadOptions>(end);
6457     return o;
6458   }
6459 };
6460
6461 inline flatbuffers::Offset<MirrorPadOptions>
6462 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb,
6463                        MirrorPadMode mode = MirrorPadMode_REFLECT)
6464 {
6465   MirrorPadOptionsBuilder builder_(_fbb);
6466   builder_.add_mode(mode);
6467   return builder_.Finish();
6468 }
6469
6470 struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6471 {
6472   enum
6473   {
6474     VT_IDX_OUT_TYPE = 4
6475   };
6476   TensorType idx_out_type() const
6477   {
6478     return static_cast<TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
6479   }
6480   bool Verify(flatbuffers::Verifier &verifier) const
6481   {
6482     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
6483            verifier.EndTable();
6484   }
6485 };
6486
6487 struct UniqueOptionsBuilder
6488 {
6489   flatbuffers::FlatBufferBuilder &fbb_;
6490   flatbuffers::uoffset_t start_;
6491   void add_idx_out_type(TensorType idx_out_type)
6492   {
6493     fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
6494   }
6495   explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6496   {
6497     start_ = fbb_.StartTable();
6498   }
6499   UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &);
6500   flatbuffers::Offset<UniqueOptions> Finish()
6501   {
6502     const auto end = fbb_.EndTable(start_);
6503     auto o = flatbuffers::Offset<UniqueOptions>(end);
6504     return o;
6505   }
6506 };
6507
6508 inline flatbuffers::Offset<UniqueOptions>
6509 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb,
6510                     TensorType idx_out_type = TensorType_INT32)
6511 {
6512   UniqueOptionsBuilder builder_(_fbb);
6513   builder_.add_idx_out_type(idx_out_type);
6514   return builder_.Finish();
6515 }
6516
6517 struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6518 {
6519   bool Verify(flatbuffers::Verifier &verifier) const
6520   {
6521     return VerifyTableStart(verifier) && verifier.EndTable();
6522   }
6523 };
6524
6525 struct ReverseV2OptionsBuilder
6526 {
6527   flatbuffers::FlatBufferBuilder &fbb_;
6528   flatbuffers::uoffset_t start_;
6529   explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6530   {
6531     start_ = fbb_.StartTable();
6532   }
6533   ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &);
6534   flatbuffers::Offset<ReverseV2Options> Finish()
6535   {
6536     const auto end = fbb_.EndTable(start_);
6537     auto o = flatbuffers::Offset<ReverseV2Options>(end);
6538     return o;
6539   }
6540 };
6541
6542 inline flatbuffers::Offset<ReverseV2Options>
6543 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb)
6544 {
6545   ReverseV2OptionsBuilder builder_(_fbb);
6546   return builder_.Finish();
6547 }
6548
6549 struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6550 {
6551   bool Verify(flatbuffers::Verifier &verifier) const
6552   {
6553     return VerifyTableStart(verifier) && verifier.EndTable();
6554   }
6555 };
6556
6557 struct AddNOptionsBuilder
6558 {
6559   flatbuffers::FlatBufferBuilder &fbb_;
6560   flatbuffers::uoffset_t start_;
6561   explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6562   {
6563     start_ = fbb_.StartTable();
6564   }
6565   AddNOptionsBuilder &operator=(const AddNOptionsBuilder &);
6566   flatbuffers::Offset<AddNOptions> Finish()
6567   {
6568     const auto end = fbb_.EndTable(start_);
6569     auto o = flatbuffers::Offset<AddNOptions>(end);
6570     return o;
6571   }
6572 };
6573
6574 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb)
6575 {
6576   AddNOptionsBuilder builder_(_fbb);
6577   return builder_.Finish();
6578 }
6579
6580 struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6581 {
6582   bool Verify(flatbuffers::Verifier &verifier) const
6583   {
6584     return VerifyTableStart(verifier) && verifier.EndTable();
6585   }
6586 };
6587
6588 struct GatherNdOptionsBuilder
6589 {
6590   flatbuffers::FlatBufferBuilder &fbb_;
6591   flatbuffers::uoffset_t start_;
6592   explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6593   {
6594     start_ = fbb_.StartTable();
6595   }
6596   GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &);
6597   flatbuffers::Offset<GatherNdOptions> Finish()
6598   {
6599     const auto end = fbb_.EndTable(start_);
6600     auto o = flatbuffers::Offset<GatherNdOptions>(end);
6601     return o;
6602   }
6603 };
6604
6605 inline flatbuffers::Offset<GatherNdOptions>
6606 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
6607 {
6608   GatherNdOptionsBuilder builder_(_fbb);
6609   return builder_.Finish();
6610 }
6611
6612 struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6613 {
6614   bool Verify(flatbuffers::Verifier &verifier) const
6615   {
6616     return VerifyTableStart(verifier) && verifier.EndTable();
6617   }
6618 };
6619
6620 struct WhereOptionsBuilder
6621 {
6622   flatbuffers::FlatBufferBuilder &fbb_;
6623   flatbuffers::uoffset_t start_;
6624   explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6625   {
6626     start_ = fbb_.StartTable();
6627   }
6628   WhereOptionsBuilder &operator=(const WhereOptionsBuilder &);
6629   flatbuffers::Offset<WhereOptions> Finish()
6630   {
6631     const auto end = fbb_.EndTable(start_);
6632     auto o = flatbuffers::Offset<WhereOptions>(end);
6633     return o;
6634   }
6635 };
6636
6637 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb)
6638 {
6639   WhereOptionsBuilder builder_(_fbb);
6640   return builder_.Finish();
6641 }
6642
6643 struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6644 {
6645   enum
6646   {
6647     VT_SEQ_DIM = 4,
6648     VT_BATCH_DIM = 6
6649   };
6650   int32_t seq_dim() const { return GetField<int32_t>(VT_SEQ_DIM, 0); }
6651   int32_t batch_dim() const { return GetField<int32_t>(VT_BATCH_DIM, 0); }
6652   bool Verify(flatbuffers::Verifier &verifier) const
6653   {
6654     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
6655            VerifyField<int32_t>(verifier, VT_BATCH_DIM) && verifier.EndTable();
6656   }
6657 };
6658
6659 struct ReverseSequenceOptionsBuilder
6660 {
6661   flatbuffers::FlatBufferBuilder &fbb_;
6662   flatbuffers::uoffset_t start_;
6663   void add_seq_dim(int32_t seq_dim)
6664   {
6665     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
6666   }
6667   void add_batch_dim(int32_t batch_dim)
6668   {
6669     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
6670   }
6671   explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6672   {
6673     start_ = fbb_.StartTable();
6674   }
6675   ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &);
6676   flatbuffers::Offset<ReverseSequenceOptions> Finish()
6677   {
6678     const auto end = fbb_.EndTable(start_);
6679     auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
6680     return o;
6681   }
6682 };
6683
6684 inline flatbuffers::Offset<ReverseSequenceOptions>
6685 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim = 0,
6686                              int32_t batch_dim = 0)
6687 {
6688   ReverseSequenceOptionsBuilder builder_(_fbb);
6689   builder_.add_batch_dim(batch_dim);
6690   builder_.add_seq_dim(seq_dim);
6691   return builder_.Finish();
6692 }
6693
6694 struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6695 {
6696   bool Verify(flatbuffers::Verifier &verifier) const
6697   {
6698     return VerifyTableStart(verifier) && verifier.EndTable();
6699   }
6700 };
6701
6702 struct MatrixDiagOptionsBuilder
6703 {
6704   flatbuffers::FlatBufferBuilder &fbb_;
6705   flatbuffers::uoffset_t start_;
6706   explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6707   {
6708     start_ = fbb_.StartTable();
6709   }
6710   MatrixDiagOptionsBuilder &operator=(const MatrixDiagOptionsBuilder &);
6711   flatbuffers::Offset<MatrixDiagOptions> Finish()
6712   {
6713     const auto end = fbb_.EndTable(start_);
6714     auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
6715     return o;
6716   }
6717 };
6718
6719 inline flatbuffers::Offset<MatrixDiagOptions>
6720 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
6721 {
6722   MatrixDiagOptionsBuilder builder_(_fbb);
6723   return builder_.Finish();
6724 }
6725
6726 struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6727 {
6728   bool Verify(flatbuffers::Verifier &verifier) const
6729   {
6730     return VerifyTableStart(verifier) && verifier.EndTable();
6731   }
6732 };
6733
6734 struct QuantizeOptionsBuilder
6735 {
6736   flatbuffers::FlatBufferBuilder &fbb_;
6737   flatbuffers::uoffset_t start_;
6738   explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6739   {
6740     start_ = fbb_.StartTable();
6741   }
6742   QuantizeOptionsBuilder &operator=(const QuantizeOptionsBuilder &);
6743   flatbuffers::Offset<QuantizeOptions> Finish()
6744   {
6745     const auto end = fbb_.EndTable(start_);
6746     auto o = flatbuffers::Offset<QuantizeOptions>(end);
6747     return o;
6748   }
6749 };
6750
6751 inline flatbuffers::Offset<QuantizeOptions>
6752 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
6753 {
6754   QuantizeOptionsBuilder builder_(_fbb);
6755   return builder_.Finish();
6756 }
6757
6758 struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6759 {
6760   bool Verify(flatbuffers::Verifier &verifier) const
6761   {
6762     return VerifyTableStart(verifier) && verifier.EndTable();
6763   }
6764 };
6765
6766 struct MatrixSetDiagOptionsBuilder
6767 {
6768   flatbuffers::FlatBufferBuilder &fbb_;
6769   flatbuffers::uoffset_t start_;
6770   explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6771   {
6772     start_ = fbb_.StartTable();
6773   }
6774   MatrixSetDiagOptionsBuilder &operator=(const MatrixSetDiagOptionsBuilder &);
6775   flatbuffers::Offset<MatrixSetDiagOptions> Finish()
6776   {
6777     const auto end = fbb_.EndTable(start_);
6778     auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
6779     return o;
6780   }
6781 };
6782
6783 inline flatbuffers::Offset<MatrixSetDiagOptions>
6784 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
6785 {
6786   MatrixSetDiagOptionsBuilder builder_(_fbb);
6787   return builder_.Finish();
6788 }
6789
6790 struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6791 {
6792   enum
6793   {
6794     VT_THEN_SUBGRAPH_INDEX = 4,
6795     VT_ELSE_SUBGRAPH_INDEX = 6
6796   };
6797   int32_t then_subgraph_index() const { return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0); }
6798   int32_t else_subgraph_index() const { return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0); }
6799   bool Verify(flatbuffers::Verifier &verifier) const
6800   {
6801     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
6802            VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) && verifier.EndTable();
6803   }
6804 };
6805
6806 struct IfOptionsBuilder
6807 {
6808   flatbuffers::FlatBufferBuilder &fbb_;
6809   flatbuffers::uoffset_t start_;
6810   void add_then_subgraph_index(int32_t then_subgraph_index)
6811   {
6812     fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
6813   }
6814   void add_else_subgraph_index(int32_t else_subgraph_index)
6815   {
6816     fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
6817   }
6818   explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6819   {
6820     start_ = fbb_.StartTable();
6821   }
6822   IfOptionsBuilder &operator=(const IfOptionsBuilder &);
6823   flatbuffers::Offset<IfOptions> Finish()
6824   {
6825     const auto end = fbb_.EndTable(start_);
6826     auto o = flatbuffers::Offset<IfOptions>(end);
6827     return o;
6828   }
6829 };
6830
6831 inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb,
6832                                                       int32_t then_subgraph_index = 0,
6833                                                       int32_t else_subgraph_index = 0)
6834 {
6835   IfOptionsBuilder builder_(_fbb);
6836   builder_.add_else_subgraph_index(else_subgraph_index);
6837   builder_.add_then_subgraph_index(then_subgraph_index);
6838   return builder_.Finish();
6839 }
6840
6841 struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6842 {
6843   enum
6844   {
6845     VT_COND_SUBGRAPH_INDEX = 4,
6846     VT_BODY_SUBGRAPH_INDEX = 6
6847   };
6848   int32_t cond_subgraph_index() const { return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0); }
6849   int32_t body_subgraph_index() const { return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0); }
6850   bool Verify(flatbuffers::Verifier &verifier) const
6851   {
6852     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
6853            VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) && verifier.EndTable();
6854   }
6855 };
6856
6857 struct WhileOptionsBuilder
6858 {
6859   flatbuffers::FlatBufferBuilder &fbb_;
6860   flatbuffers::uoffset_t start_;
6861   void add_cond_subgraph_index(int32_t cond_subgraph_index)
6862   {
6863     fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
6864   }
6865   void add_body_subgraph_index(int32_t body_subgraph_index)
6866   {
6867     fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
6868   }
6869   explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6870   {
6871     start_ = fbb_.StartTable();
6872   }
6873   WhileOptionsBuilder &operator=(const WhileOptionsBuilder &);
6874   flatbuffers::Offset<WhileOptions> Finish()
6875   {
6876     const auto end = fbb_.EndTable(start_);
6877     auto o = flatbuffers::Offset<WhileOptions>(end);
6878     return o;
6879   }
6880 };
6881
6882 inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb,
6883                                                             int32_t cond_subgraph_index = 0,
6884                                                             int32_t body_subgraph_index = 0)
6885 {
6886   WhileOptionsBuilder builder_(_fbb);
6887   builder_.add_body_subgraph_index(body_subgraph_index);
6888   builder_.add_cond_subgraph_index(cond_subgraph_index);
6889   return builder_.Finish();
6890 }
6891
6892 struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6893 {
6894   bool Verify(flatbuffers::Verifier &verifier) const
6895   {
6896     return VerifyTableStart(verifier) && verifier.EndTable();
6897   }
6898 };
6899
6900 struct NonMaxSuppressionV4OptionsBuilder
6901 {
6902   flatbuffers::FlatBufferBuilder &fbb_;
6903   flatbuffers::uoffset_t start_;
6904   explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6905   {
6906     start_ = fbb_.StartTable();
6907   }
6908   NonMaxSuppressionV4OptionsBuilder &operator=(const NonMaxSuppressionV4OptionsBuilder &);
6909   flatbuffers::Offset<NonMaxSuppressionV4Options> Finish()
6910   {
6911     const auto end = fbb_.EndTable(start_);
6912     auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
6913     return o;
6914   }
6915 };
6916
6917 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
6918 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb)
6919 {
6920   NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
6921   return builder_.Finish();
6922 }
6923
6924 struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6925 {
6926   bool Verify(flatbuffers::Verifier &verifier) const
6927   {
6928     return VerifyTableStart(verifier) && verifier.EndTable();
6929   }
6930 };
6931
6932 struct NonMaxSuppressionV5OptionsBuilder
6933 {
6934   flatbuffers::FlatBufferBuilder &fbb_;
6935   flatbuffers::uoffset_t start_;
6936   explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6937   {
6938     start_ = fbb_.StartTable();
6939   }
6940   NonMaxSuppressionV5OptionsBuilder &operator=(const NonMaxSuppressionV5OptionsBuilder &);
6941   flatbuffers::Offset<NonMaxSuppressionV5Options> Finish()
6942   {
6943     const auto end = fbb_.EndTable(start_);
6944     auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
6945     return o;
6946   }
6947 };
6948
6949 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
6950 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb)
6951 {
6952   NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
6953   return builder_.Finish();
6954 }
6955
6956 struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6957 {
6958   bool Verify(flatbuffers::Verifier &verifier) const
6959   {
6960     return VerifyTableStart(verifier) && verifier.EndTable();
6961   }
6962 };
6963
6964 struct ScatterNdOptionsBuilder
6965 {
6966   flatbuffers::FlatBufferBuilder &fbb_;
6967   flatbuffers::uoffset_t start_;
6968   explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6969   {
6970     start_ = fbb_.StartTable();
6971   }
6972   ScatterNdOptionsBuilder &operator=(const ScatterNdOptionsBuilder &);
6973   flatbuffers::Offset<ScatterNdOptions> Finish()
6974   {
6975     const auto end = fbb_.EndTable(start_);
6976     auto o = flatbuffers::Offset<ScatterNdOptions>(end);
6977     return o;
6978   }
6979 };
6980
6981 inline flatbuffers::Offset<ScatterNdOptions>
6982 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
6983 {
6984   ScatterNdOptionsBuilder builder_(_fbb);
6985   return builder_.Finish();
6986 }
6987
6988 struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6989 {
6990   bool Verify(flatbuffers::Verifier &verifier) const
6991   {
6992     return VerifyTableStart(verifier) && verifier.EndTable();
6993   }
6994 };
6995
6996 struct SelectV2OptionsBuilder
6997 {
6998   flatbuffers::FlatBufferBuilder &fbb_;
6999   flatbuffers::uoffset_t start_;
7000   explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7001   {
7002     start_ = fbb_.StartTable();
7003   }
7004   SelectV2OptionsBuilder &operator=(const SelectV2OptionsBuilder &);
7005   flatbuffers::Offset<SelectV2Options> Finish()
7006   {
7007     const auto end = fbb_.EndTable(start_);
7008     auto o = flatbuffers::Offset<SelectV2Options>(end);
7009     return o;
7010   }
7011 };
7012
7013 inline flatbuffers::Offset<SelectV2Options>
7014 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7015 {
7016   SelectV2OptionsBuilder builder_(_fbb);
7017   return builder_.Finish();
7018 }
7019
7020 struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7021 {
7022   bool Verify(flatbuffers::Verifier &verifier) const
7023   {
7024     return VerifyTableStart(verifier) && verifier.EndTable();
7025   }
7026 };
7027
7028 struct DensifyOptionsBuilder
7029 {
7030   flatbuffers::FlatBufferBuilder &fbb_;
7031   flatbuffers::uoffset_t start_;
7032   explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7033   {
7034     start_ = fbb_.StartTable();
7035   }
7036   DensifyOptionsBuilder &operator=(const DensifyOptionsBuilder &);
7037   flatbuffers::Offset<DensifyOptions> Finish()
7038   {
7039     const auto end = fbb_.EndTable(start_);
7040     auto o = flatbuffers::Offset<DensifyOptions>(end);
7041     return o;
7042   }
7043 };
7044
7045 inline flatbuffers::Offset<DensifyOptions>
7046 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb)
7047 {
7048   DensifyOptionsBuilder builder_(_fbb);
7049   return builder_.Finish();
7050 }
7051
7052 struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7053 {
7054   bool Verify(flatbuffers::Verifier &verifier) const
7055   {
7056     return VerifyTableStart(verifier) && verifier.EndTable();
7057   }
7058 };
7059
7060 struct SegmentSumOptionsBuilder
7061 {
7062   flatbuffers::FlatBufferBuilder &fbb_;
7063   flatbuffers::uoffset_t start_;
7064   explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7065   {
7066     start_ = fbb_.StartTable();
7067   }
7068   SegmentSumOptionsBuilder &operator=(const SegmentSumOptionsBuilder &);
7069   flatbuffers::Offset<SegmentSumOptions> Finish()
7070   {
7071     const auto end = fbb_.EndTable(start_);
7072     auto o = flatbuffers::Offset<SegmentSumOptions>(end);
7073     return o;
7074   }
7075 };
7076
7077 inline flatbuffers::Offset<SegmentSumOptions>
7078 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
7079 {
7080   SegmentSumOptionsBuilder builder_(_fbb);
7081   return builder_.Finish();
7082 }
7083
7084 struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7085 {
7086   enum
7087   {
7088     VT_ADJOINT_LHS = 4,
7089     VT_ADJOINT_RHS = 6
7090   };
7091   bool adjoint_lhs() const { return GetField<uint8_t>(VT_ADJOINT_LHS, 0) != 0; }
7092   bool adjoint_rhs() const { return GetField<uint8_t>(VT_ADJOINT_RHS, 0) != 0; }
7093   bool Verify(flatbuffers::Verifier &verifier) const
7094   {
7095     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ADJOINT_LHS) &&
7096            VerifyField<uint8_t>(verifier, VT_ADJOINT_RHS) && verifier.EndTable();
7097   }
7098 };
7099
7100 struct BatchMatMulOptionsBuilder
7101 {
7102   flatbuffers::FlatBufferBuilder &fbb_;
7103   flatbuffers::uoffset_t start_;
7104   void add_adjoint_lhs(bool adjoint_lhs)
7105   {
7106     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_LHS, static_cast<uint8_t>(adjoint_lhs),
7107                              0);
7108   }
7109   void add_adjoint_rhs(bool adjoint_rhs)
7110   {
7111     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_RHS, static_cast<uint8_t>(adjoint_rhs),
7112                              0);
7113   }
7114   explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7115   {
7116     start_ = fbb_.StartTable();
7117   }
7118   BatchMatMulOptionsBuilder &operator=(const BatchMatMulOptionsBuilder &);
7119   flatbuffers::Offset<BatchMatMulOptions> Finish()
7120   {
7121     const auto end = fbb_.EndTable(start_);
7122     auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
7123     return o;
7124   }
7125 };
7126
7127 inline flatbuffers::Offset<BatchMatMulOptions>
7128 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, bool adjoint_lhs = false,
7129                          bool adjoint_rhs = false)
7130 {
7131   BatchMatMulOptionsBuilder builder_(_fbb);
7132   builder_.add_adjoint_rhs(adjoint_rhs);
7133   builder_.add_adjoint_lhs(adjoint_lhs);
7134   return builder_.Finish();
7135 }
7136
7137 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7138 {
7139   enum
7140   {
7141     VT_BUILTIN_CODE = 4,
7142     VT_CUSTOM_CODE = 6,
7143     VT_VERSION = 8
7144   };
7145   BuiltinOperator builtin_code() const
7146   {
7147     return static_cast<BuiltinOperator>(GetField<int8_t>(VT_BUILTIN_CODE, 0));
7148   }
7149   const flatbuffers::String *custom_code() const
7150   {
7151     return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
7152   }
7153   int32_t version() const { return GetField<int32_t>(VT_VERSION, 1); }
7154   bool Verify(flatbuffers::Verifier &verifier) const
7155   {
7156     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_BUILTIN_CODE) &&
7157            VerifyOffset(verifier, VT_CUSTOM_CODE) && verifier.VerifyString(custom_code()) &&
7158            VerifyField<int32_t>(verifier, VT_VERSION) && verifier.EndTable();
7159   }
7160 };
7161
7162 struct OperatorCodeBuilder
7163 {
7164   flatbuffers::FlatBufferBuilder &fbb_;
7165   flatbuffers::uoffset_t start_;
7166   void add_builtin_code(BuiltinOperator builtin_code)
7167   {
7168     fbb_.AddElement<int8_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int8_t>(builtin_code), 0);
7169   }
7170   void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code)
7171   {
7172     fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
7173   }
7174   void add_version(int32_t version)
7175   {
7176     fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
7177   }
7178   explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7179   {
7180     start_ = fbb_.StartTable();
7181   }
7182   OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
7183   flatbuffers::Offset<OperatorCode> Finish()
7184   {
7185     const auto end = fbb_.EndTable(start_);
7186     auto o = flatbuffers::Offset<OperatorCode>(end);
7187     return o;
7188   }
7189 };
7190
7191 inline flatbuffers::Offset<OperatorCode>
7192 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb,
7193                    BuiltinOperator builtin_code = BuiltinOperator_ADD,
7194                    flatbuffers::Offset<flatbuffers::String> custom_code = 0, int32_t version = 1)
7195 {
7196   OperatorCodeBuilder builder_(_fbb);
7197   builder_.add_version(version);
7198   builder_.add_custom_code(custom_code);
7199   builder_.add_builtin_code(builtin_code);
7200   return builder_.Finish();
7201 }
7202
7203 inline flatbuffers::Offset<OperatorCode>
7204 CreateOperatorCodeDirect(flatbuffers::FlatBufferBuilder &_fbb,
7205                          BuiltinOperator builtin_code = BuiltinOperator_ADD,
7206                          const char *custom_code = nullptr, int32_t version = 1)
7207 {
7208   return onert_tflite::CreateOperatorCode(
7209       _fbb, builtin_code, custom_code ? _fbb.CreateString(custom_code) : 0, version);
7210 }
7211
7212 struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7213 {
7214   enum
7215   {
7216     VT_OPCODE_INDEX = 4,
7217     VT_INPUTS = 6,
7218     VT_OUTPUTS = 8,
7219     VT_BUILTIN_OPTIONS_TYPE = 10,
7220     VT_BUILTIN_OPTIONS = 12,
7221     VT_CUSTOM_OPTIONS = 14,
7222     VT_CUSTOM_OPTIONS_FORMAT = 16,
7223     VT_MUTATING_VARIABLE_INPUTS = 18,
7224     VT_INTERMEDIATES = 20
7225   };
7226   uint32_t opcode_index() const { return GetField<uint32_t>(VT_OPCODE_INDEX, 0); }
7227   const flatbuffers::Vector<int32_t> *inputs() const
7228   {
7229     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
7230   }
7231   const flatbuffers::Vector<int32_t> *outputs() const
7232   {
7233     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
7234   }
7235   BuiltinOptions builtin_options_type() const
7236   {
7237     return static_cast<BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
7238   }
7239   const void *builtin_options() const { return GetPointer<const void *>(VT_BUILTIN_OPTIONS); }
7240   template <typename T> const T *builtin_options_as() const;
7241   const Conv2DOptions *builtin_options_as_Conv2DOptions() const
7242   {
7243     return builtin_options_type() == BuiltinOptions_Conv2DOptions
7244                ? static_cast<const Conv2DOptions *>(builtin_options())
7245                : nullptr;
7246   }
7247   const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const
7248   {
7249     return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions
7250                ? static_cast<const DepthwiseConv2DOptions *>(builtin_options())
7251                : nullptr;
7252   }
7253   const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const
7254   {
7255     return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions
7256                ? static_cast<const ConcatEmbeddingsOptions *>(builtin_options())
7257                : nullptr;
7258   }
7259   const LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const
7260   {
7261     return builtin_options_type() == BuiltinOptions_LSHProjectionOptions
7262                ? static_cast<const LSHProjectionOptions *>(builtin_options())
7263                : nullptr;
7264   }
7265   const Pool2DOptions *builtin_options_as_Pool2DOptions() const
7266   {
7267     return builtin_options_type() == BuiltinOptions_Pool2DOptions
7268                ? static_cast<const Pool2DOptions *>(builtin_options())
7269                : nullptr;
7270   }
7271   const SVDFOptions *builtin_options_as_SVDFOptions() const
7272   {
7273     return builtin_options_type() == BuiltinOptions_SVDFOptions
7274                ? static_cast<const SVDFOptions *>(builtin_options())
7275                : nullptr;
7276   }
7277   const RNNOptions *builtin_options_as_RNNOptions() const
7278   {
7279     return builtin_options_type() == BuiltinOptions_RNNOptions
7280                ? static_cast<const RNNOptions *>(builtin_options())
7281                : nullptr;
7282   }
7283   const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const
7284   {
7285     return builtin_options_type() == BuiltinOptions_FullyConnectedOptions
7286                ? static_cast<const FullyConnectedOptions *>(builtin_options())
7287                : nullptr;
7288   }
7289   const SoftmaxOptions *builtin_options_as_SoftmaxOptions() const
7290   {
7291     return builtin_options_type() == BuiltinOptions_SoftmaxOptions
7292                ? static_cast<const SoftmaxOptions *>(builtin_options())
7293                : nullptr;
7294   }
7295   const ConcatenationOptions *builtin_options_as_ConcatenationOptions() const
7296   {
7297     return builtin_options_type() == BuiltinOptions_ConcatenationOptions
7298                ? static_cast<const ConcatenationOptions *>(builtin_options())
7299                : nullptr;
7300   }
7301   const AddOptions *builtin_options_as_AddOptions() const
7302   {
7303     return builtin_options_type() == BuiltinOptions_AddOptions
7304                ? static_cast<const AddOptions *>(builtin_options())
7305                : nullptr;
7306   }
7307   const L2NormOptions *builtin_options_as_L2NormOptions() const
7308   {
7309     return builtin_options_type() == BuiltinOptions_L2NormOptions
7310                ? static_cast<const L2NormOptions *>(builtin_options())
7311                : nullptr;
7312   }
7313   const LocalResponseNormalizationOptions *
7314   builtin_options_as_LocalResponseNormalizationOptions() const
7315   {
7316     return builtin_options_type() == BuiltinOptions_LocalResponseNormalizationOptions
7317                ? static_cast<const LocalResponseNormalizationOptions *>(builtin_options())
7318                : nullptr;
7319   }
7320   const LSTMOptions *builtin_options_as_LSTMOptions() const
7321   {
7322     return builtin_options_type() == BuiltinOptions_LSTMOptions
7323                ? static_cast<const LSTMOptions *>(builtin_options())
7324                : nullptr;
7325   }
7326   const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const
7327   {
7328     return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions
7329                ? static_cast<const ResizeBilinearOptions *>(builtin_options())
7330                : nullptr;
7331   }
7332   const CallOptions *builtin_options_as_CallOptions() const
7333   {
7334     return builtin_options_type() == BuiltinOptions_CallOptions
7335                ? static_cast<const CallOptions *>(builtin_options())
7336                : nullptr;
7337   }
7338   const ReshapeOptions *builtin_options_as_ReshapeOptions() const
7339   {
7340     return builtin_options_type() == BuiltinOptions_ReshapeOptions
7341                ? static_cast<const ReshapeOptions *>(builtin_options())
7342                : nullptr;
7343   }
7344   const SkipGramOptions *builtin_options_as_SkipGramOptions() const
7345   {
7346     return builtin_options_type() == BuiltinOptions_SkipGramOptions
7347                ? static_cast<const SkipGramOptions *>(builtin_options())
7348                : nullptr;
7349   }
7350   const SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const
7351   {
7352     return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions
7353                ? static_cast<const SpaceToDepthOptions *>(builtin_options())
7354                : nullptr;
7355   }
7356   const EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const
7357   {
7358     return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions
7359                ? static_cast<const EmbeddingLookupSparseOptions *>(builtin_options())
7360                : nullptr;
7361   }
7362   const MulOptions *builtin_options_as_MulOptions() const
7363   {
7364     return builtin_options_type() == BuiltinOptions_MulOptions
7365                ? static_cast<const MulOptions *>(builtin_options())
7366                : nullptr;
7367   }
7368   const PadOptions *builtin_options_as_PadOptions() const
7369   {
7370     return builtin_options_type() == BuiltinOptions_PadOptions
7371                ? static_cast<const PadOptions *>(builtin_options())
7372                : nullptr;
7373   }
7374   const GatherOptions *builtin_options_as_GatherOptions() const
7375   {
7376     return builtin_options_type() == BuiltinOptions_GatherOptions
7377                ? static_cast<const GatherOptions *>(builtin_options())
7378                : nullptr;
7379   }
7380   const BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const
7381   {
7382     return builtin_options_type() == BuiltinOptions_BatchToSpaceNDOptions
7383                ? static_cast<const BatchToSpaceNDOptions *>(builtin_options())
7384                : nullptr;
7385   }
7386   const SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const
7387   {
7388     return builtin_options_type() == BuiltinOptions_SpaceToBatchNDOptions
7389                ? static_cast<const SpaceToBatchNDOptions *>(builtin_options())
7390                : nullptr;
7391   }
7392   const TransposeOptions *builtin_options_as_TransposeOptions() const
7393   {
7394     return builtin_options_type() == BuiltinOptions_TransposeOptions
7395                ? static_cast<const TransposeOptions *>(builtin_options())
7396                : nullptr;
7397   }
7398   const ReducerOptions *builtin_options_as_ReducerOptions() const
7399   {
7400     return builtin_options_type() == BuiltinOptions_ReducerOptions
7401                ? static_cast<const ReducerOptions *>(builtin_options())
7402                : nullptr;
7403   }
7404   const SubOptions *builtin_options_as_SubOptions() const
7405   {
7406     return builtin_options_type() == BuiltinOptions_SubOptions
7407                ? static_cast<const SubOptions *>(builtin_options())
7408                : nullptr;
7409   }
7410   const DivOptions *builtin_options_as_DivOptions() const
7411   {
7412     return builtin_options_type() == BuiltinOptions_DivOptions
7413                ? static_cast<const DivOptions *>(builtin_options())
7414                : nullptr;
7415   }
7416   const SqueezeOptions *builtin_options_as_SqueezeOptions() const
7417   {
7418     return builtin_options_type() == BuiltinOptions_SqueezeOptions
7419                ? static_cast<const SqueezeOptions *>(builtin_options())
7420                : nullptr;
7421   }
7422   const SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const
7423   {
7424     return builtin_options_type() == BuiltinOptions_SequenceRNNOptions
7425                ? static_cast<const SequenceRNNOptions *>(builtin_options())
7426                : nullptr;
7427   }
7428   const StridedSliceOptions *builtin_options_as_StridedSliceOptions() const
7429   {
7430     return builtin_options_type() == BuiltinOptions_StridedSliceOptions
7431                ? static_cast<const StridedSliceOptions *>(builtin_options())
7432                : nullptr;
7433   }
7434   const ExpOptions *builtin_options_as_ExpOptions() const
7435   {
7436     return builtin_options_type() == BuiltinOptions_ExpOptions
7437                ? static_cast<const ExpOptions *>(builtin_options())
7438                : nullptr;
7439   }
7440   const TopKV2Options *builtin_options_as_TopKV2Options() const
7441   {
7442     return builtin_options_type() == BuiltinOptions_TopKV2Options
7443                ? static_cast<const TopKV2Options *>(builtin_options())
7444                : nullptr;
7445   }
7446   const SplitOptions *builtin_options_as_SplitOptions() const
7447   {
7448     return builtin_options_type() == BuiltinOptions_SplitOptions
7449                ? static_cast<const SplitOptions *>(builtin_options())
7450                : nullptr;
7451   }
7452   const LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const
7453   {
7454     return builtin_options_type() == BuiltinOptions_LogSoftmaxOptions
7455                ? static_cast<const LogSoftmaxOptions *>(builtin_options())
7456                : nullptr;
7457   }
7458   const CastOptions *builtin_options_as_CastOptions() const
7459   {
7460     return builtin_options_type() == BuiltinOptions_CastOptions
7461                ? static_cast<const CastOptions *>(builtin_options())
7462                : nullptr;
7463   }
7464   const DequantizeOptions *builtin_options_as_DequantizeOptions() const
7465   {
7466     return builtin_options_type() == BuiltinOptions_DequantizeOptions
7467                ? static_cast<const DequantizeOptions *>(builtin_options())
7468                : nullptr;
7469   }
7470   const MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const
7471   {
7472     return builtin_options_type() == BuiltinOptions_MaximumMinimumOptions
7473                ? static_cast<const MaximumMinimumOptions *>(builtin_options())
7474                : nullptr;
7475   }
7476   const ArgMaxOptions *builtin_options_as_ArgMaxOptions() const
7477   {
7478     return builtin_options_type() == BuiltinOptions_ArgMaxOptions
7479                ? static_cast<const ArgMaxOptions *>(builtin_options())
7480                : nullptr;
7481   }
7482   const LessOptions *builtin_options_as_LessOptions() const
7483   {
7484     return builtin_options_type() == BuiltinOptions_LessOptions
7485                ? static_cast<const LessOptions *>(builtin_options())
7486                : nullptr;
7487   }
7488   const NegOptions *builtin_options_as_NegOptions() const
7489   {
7490     return builtin_options_type() == BuiltinOptions_NegOptions
7491                ? static_cast<const NegOptions *>(builtin_options())
7492                : nullptr;
7493   }
7494   const PadV2Options *builtin_options_as_PadV2Options() const
7495   {
7496     return builtin_options_type() == BuiltinOptions_PadV2Options
7497                ? static_cast<const PadV2Options *>(builtin_options())
7498                : nullptr;
7499   }
7500   const GreaterOptions *builtin_options_as_GreaterOptions() const
7501   {
7502     return builtin_options_type() == BuiltinOptions_GreaterOptions
7503                ? static_cast<const GreaterOptions *>(builtin_options())
7504                : nullptr;
7505   }
7506   const GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const
7507   {
7508     return builtin_options_type() == BuiltinOptions_GreaterEqualOptions
7509                ? static_cast<const GreaterEqualOptions *>(builtin_options())
7510                : nullptr;
7511   }
7512   const LessEqualOptions *builtin_options_as_LessEqualOptions() const
7513   {
7514     return builtin_options_type() == BuiltinOptions_LessEqualOptions
7515                ? static_cast<const LessEqualOptions *>(builtin_options())
7516                : nullptr;
7517   }
7518   const SelectOptions *builtin_options_as_SelectOptions() const
7519   {
7520     return builtin_options_type() == BuiltinOptions_SelectOptions
7521                ? static_cast<const SelectOptions *>(builtin_options())
7522                : nullptr;
7523   }
7524   const SliceOptions *builtin_options_as_SliceOptions() const
7525   {
7526     return builtin_options_type() == BuiltinOptions_SliceOptions
7527                ? static_cast<const SliceOptions *>(builtin_options())
7528                : nullptr;
7529   }
7530   const TransposeConvOptions *builtin_options_as_TransposeConvOptions() const
7531   {
7532     return builtin_options_type() == BuiltinOptions_TransposeConvOptions
7533                ? static_cast<const TransposeConvOptions *>(builtin_options())
7534                : nullptr;
7535   }
7536   const SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const
7537   {
7538     return builtin_options_type() == BuiltinOptions_SparseToDenseOptions
7539                ? static_cast<const SparseToDenseOptions *>(builtin_options())
7540                : nullptr;
7541   }
7542   const TileOptions *builtin_options_as_TileOptions() const
7543   {
7544     return builtin_options_type() == BuiltinOptions_TileOptions
7545                ? static_cast<const TileOptions *>(builtin_options())
7546                : nullptr;
7547   }
7548   const ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const
7549   {
7550     return builtin_options_type() == BuiltinOptions_ExpandDimsOptions
7551                ? static_cast<const ExpandDimsOptions *>(builtin_options())
7552                : nullptr;
7553   }
7554   const EqualOptions *builtin_options_as_EqualOptions() const
7555   {
7556     return builtin_options_type() == BuiltinOptions_EqualOptions
7557                ? static_cast<const EqualOptions *>(builtin_options())
7558                : nullptr;
7559   }
7560   const NotEqualOptions *builtin_options_as_NotEqualOptions() const
7561   {
7562     return builtin_options_type() == BuiltinOptions_NotEqualOptions
7563                ? static_cast<const NotEqualOptions *>(builtin_options())
7564                : nullptr;
7565   }
7566   const ShapeOptions *builtin_options_as_ShapeOptions() const
7567   {
7568     return builtin_options_type() == BuiltinOptions_ShapeOptions
7569                ? static_cast<const ShapeOptions *>(builtin_options())
7570                : nullptr;
7571   }
7572   const PowOptions *builtin_options_as_PowOptions() const
7573   {
7574     return builtin_options_type() == BuiltinOptions_PowOptions
7575                ? static_cast<const PowOptions *>(builtin_options())
7576                : nullptr;
7577   }
7578   const ArgMinOptions *builtin_options_as_ArgMinOptions() const
7579   {
7580     return builtin_options_type() == BuiltinOptions_ArgMinOptions
7581                ? static_cast<const ArgMinOptions *>(builtin_options())
7582                : nullptr;
7583   }
7584   const FakeQuantOptions *builtin_options_as_FakeQuantOptions() const
7585   {
7586     return builtin_options_type() == BuiltinOptions_FakeQuantOptions
7587                ? static_cast<const FakeQuantOptions *>(builtin_options())
7588                : nullptr;
7589   }
7590   const PackOptions *builtin_options_as_PackOptions() const
7591   {
7592     return builtin_options_type() == BuiltinOptions_PackOptions
7593                ? static_cast<const PackOptions *>(builtin_options())
7594                : nullptr;
7595   }
7596   const LogicalOrOptions *builtin_options_as_LogicalOrOptions() const
7597   {
7598     return builtin_options_type() == BuiltinOptions_LogicalOrOptions
7599                ? static_cast<const LogicalOrOptions *>(builtin_options())
7600                : nullptr;
7601   }
7602   const OneHotOptions *builtin_options_as_OneHotOptions() const
7603   {
7604     return builtin_options_type() == BuiltinOptions_OneHotOptions
7605                ? static_cast<const OneHotOptions *>(builtin_options())
7606                : nullptr;
7607   }
7608   const LogicalAndOptions *builtin_options_as_LogicalAndOptions() const
7609   {
7610     return builtin_options_type() == BuiltinOptions_LogicalAndOptions
7611                ? static_cast<const LogicalAndOptions *>(builtin_options())
7612                : nullptr;
7613   }
7614   const LogicalNotOptions *builtin_options_as_LogicalNotOptions() const
7615   {
7616     return builtin_options_type() == BuiltinOptions_LogicalNotOptions
7617                ? static_cast<const LogicalNotOptions *>(builtin_options())
7618                : nullptr;
7619   }
7620   const UnpackOptions *builtin_options_as_UnpackOptions() const
7621   {
7622     return builtin_options_type() == BuiltinOptions_UnpackOptions
7623                ? static_cast<const UnpackOptions *>(builtin_options())
7624                : nullptr;
7625   }
7626   const FloorDivOptions *builtin_options_as_FloorDivOptions() const
7627   {
7628     return builtin_options_type() == BuiltinOptions_FloorDivOptions
7629                ? static_cast<const FloorDivOptions *>(builtin_options())
7630                : nullptr;
7631   }
7632   const SquareOptions *builtin_options_as_SquareOptions() const
7633   {
7634     return builtin_options_type() == BuiltinOptions_SquareOptions
7635                ? static_cast<const SquareOptions *>(builtin_options())
7636                : nullptr;
7637   }
7638   const ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const
7639   {
7640     return builtin_options_type() == BuiltinOptions_ZerosLikeOptions
7641                ? static_cast<const ZerosLikeOptions *>(builtin_options())
7642                : nullptr;
7643   }
7644   const FillOptions *builtin_options_as_FillOptions() const
7645   {
7646     return builtin_options_type() == BuiltinOptions_FillOptions
7647                ? static_cast<const FillOptions *>(builtin_options())
7648                : nullptr;
7649   }
7650   const BidirectionalSequenceLSTMOptions *
7651   builtin_options_as_BidirectionalSequenceLSTMOptions() const
7652   {
7653     return builtin_options_type() == BuiltinOptions_BidirectionalSequenceLSTMOptions
7654                ? static_cast<const BidirectionalSequenceLSTMOptions *>(builtin_options())
7655                : nullptr;
7656   }
7657   const BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const
7658   {
7659     return builtin_options_type() == BuiltinOptions_BidirectionalSequenceRNNOptions
7660                ? static_cast<const BidirectionalSequenceRNNOptions *>(builtin_options())
7661                : nullptr;
7662   }
7663   const UnidirectionalSequenceLSTMOptions *
7664   builtin_options_as_UnidirectionalSequenceLSTMOptions() const
7665   {
7666     return builtin_options_type() == BuiltinOptions_UnidirectionalSequenceLSTMOptions
7667                ? static_cast<const UnidirectionalSequenceLSTMOptions *>(builtin_options())
7668                : nullptr;
7669   }
7670   const FloorModOptions *builtin_options_as_FloorModOptions() const
7671   {
7672     return builtin_options_type() == BuiltinOptions_FloorModOptions
7673                ? static_cast<const FloorModOptions *>(builtin_options())
7674                : nullptr;
7675   }
7676   const RangeOptions *builtin_options_as_RangeOptions() const
7677   {
7678     return builtin_options_type() == BuiltinOptions_RangeOptions
7679                ? static_cast<const RangeOptions *>(builtin_options())
7680                : nullptr;
7681   }
7682   const ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const
7683   {
7684     return builtin_options_type() == BuiltinOptions_ResizeNearestNeighborOptions
7685                ? static_cast<const ResizeNearestNeighborOptions *>(builtin_options())
7686                : nullptr;
7687   }
7688   const LeakyReluOptions *builtin_options_as_LeakyReluOptions() const
7689   {
7690     return builtin_options_type() == BuiltinOptions_LeakyReluOptions
7691                ? static_cast<const LeakyReluOptions *>(builtin_options())
7692                : nullptr;
7693   }
7694   const SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const
7695   {
7696     return builtin_options_type() == BuiltinOptions_SquaredDifferenceOptions
7697                ? static_cast<const SquaredDifferenceOptions *>(builtin_options())
7698                : nullptr;
7699   }
7700   const MirrorPadOptions *builtin_options_as_MirrorPadOptions() const
7701   {
7702     return builtin_options_type() == BuiltinOptions_MirrorPadOptions
7703                ? static_cast<const MirrorPadOptions *>(builtin_options())
7704                : nullptr;
7705   }
7706   const AbsOptions *builtin_options_as_AbsOptions() const
7707   {
7708     return builtin_options_type() == BuiltinOptions_AbsOptions
7709                ? static_cast<const AbsOptions *>(builtin_options())
7710                : nullptr;
7711   }
7712   const SplitVOptions *builtin_options_as_SplitVOptions() const
7713   {
7714     return builtin_options_type() == BuiltinOptions_SplitVOptions
7715                ? static_cast<const SplitVOptions *>(builtin_options())
7716                : nullptr;
7717   }
7718   const UniqueOptions *builtin_options_as_UniqueOptions() const
7719   {
7720     return builtin_options_type() == BuiltinOptions_UniqueOptions
7721                ? static_cast<const UniqueOptions *>(builtin_options())
7722                : nullptr;
7723   }
7724   const ReverseV2Options *builtin_options_as_ReverseV2Options() const
7725   {
7726     return builtin_options_type() == BuiltinOptions_ReverseV2Options
7727                ? static_cast<const ReverseV2Options *>(builtin_options())
7728                : nullptr;
7729   }
7730   const AddNOptions *builtin_options_as_AddNOptions() const
7731   {
7732     return builtin_options_type() == BuiltinOptions_AddNOptions
7733                ? static_cast<const AddNOptions *>(builtin_options())
7734                : nullptr;
7735   }
7736   const GatherNdOptions *builtin_options_as_GatherNdOptions() const
7737   {
7738     return builtin_options_type() == BuiltinOptions_GatherNdOptions
7739                ? static_cast<const GatherNdOptions *>(builtin_options())
7740                : nullptr;
7741   }
7742   const CosOptions *builtin_options_as_CosOptions() const
7743   {
7744     return builtin_options_type() == BuiltinOptions_CosOptions
7745                ? static_cast<const CosOptions *>(builtin_options())
7746                : nullptr;
7747   }
7748   const WhereOptions *builtin_options_as_WhereOptions() const
7749   {
7750     return builtin_options_type() == BuiltinOptions_WhereOptions
7751                ? static_cast<const WhereOptions *>(builtin_options())
7752                : nullptr;
7753   }
7754   const RankOptions *builtin_options_as_RankOptions() const
7755   {
7756     return builtin_options_type() == BuiltinOptions_RankOptions
7757                ? static_cast<const RankOptions *>(builtin_options())
7758                : nullptr;
7759   }
7760   const ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const
7761   {
7762     return builtin_options_type() == BuiltinOptions_ReverseSequenceOptions
7763                ? static_cast<const ReverseSequenceOptions *>(builtin_options())
7764                : nullptr;
7765   }
7766   const MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const
7767   {
7768     return builtin_options_type() == BuiltinOptions_MatrixDiagOptions
7769                ? static_cast<const MatrixDiagOptions *>(builtin_options())
7770                : nullptr;
7771   }
7772   const QuantizeOptions *builtin_options_as_QuantizeOptions() const
7773   {
7774     return builtin_options_type() == BuiltinOptions_QuantizeOptions
7775                ? static_cast<const QuantizeOptions *>(builtin_options())
7776                : nullptr;
7777   }
7778   const MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const
7779   {
7780     return builtin_options_type() == BuiltinOptions_MatrixSetDiagOptions
7781                ? static_cast<const MatrixSetDiagOptions *>(builtin_options())
7782                : nullptr;
7783   }
7784   const HardSwishOptions *builtin_options_as_HardSwishOptions() const
7785   {
7786     return builtin_options_type() == BuiltinOptions_HardSwishOptions
7787                ? static_cast<const HardSwishOptions *>(builtin_options())
7788                : nullptr;
7789   }
7790   const IfOptions *builtin_options_as_IfOptions() const
7791   {
7792     return builtin_options_type() == BuiltinOptions_IfOptions
7793                ? static_cast<const IfOptions *>(builtin_options())
7794                : nullptr;
7795   }
7796   const WhileOptions *builtin_options_as_WhileOptions() const
7797   {
7798     return builtin_options_type() == BuiltinOptions_WhileOptions
7799                ? static_cast<const WhileOptions *>(builtin_options())
7800                : nullptr;
7801   }
7802   const DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const
7803   {
7804     return builtin_options_type() == BuiltinOptions_DepthToSpaceOptions
7805                ? static_cast<const DepthToSpaceOptions *>(builtin_options())
7806                : nullptr;
7807   }
7808   const NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const
7809   {
7810     return builtin_options_type() == BuiltinOptions_NonMaxSuppressionV4Options
7811                ? static_cast<const NonMaxSuppressionV4Options *>(builtin_options())
7812                : nullptr;
7813   }
7814   const NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const
7815   {
7816     return builtin_options_type() == BuiltinOptions_NonMaxSuppressionV5Options
7817                ? static_cast<const NonMaxSuppressionV5Options *>(builtin_options())
7818                : nullptr;
7819   }
7820   const ScatterNdOptions *builtin_options_as_ScatterNdOptions() const
7821   {
7822     return builtin_options_type() == BuiltinOptions_ScatterNdOptions
7823                ? static_cast<const ScatterNdOptions *>(builtin_options())
7824                : nullptr;
7825   }
7826   const SelectV2Options *builtin_options_as_SelectV2Options() const
7827   {
7828     return builtin_options_type() == BuiltinOptions_SelectV2Options
7829                ? static_cast<const SelectV2Options *>(builtin_options())
7830                : nullptr;
7831   }
7832   const DensifyOptions *builtin_options_as_DensifyOptions() const
7833   {
7834     return builtin_options_type() == BuiltinOptions_DensifyOptions
7835                ? static_cast<const DensifyOptions *>(builtin_options())
7836                : nullptr;
7837   }
7838   const SegmentSumOptions *builtin_options_as_SegmentSumOptions() const
7839   {
7840     return builtin_options_type() == BuiltinOptions_SegmentSumOptions
7841                ? static_cast<const SegmentSumOptions *>(builtin_options())
7842                : nullptr;
7843   }
7844   const BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const
7845   {
7846     return builtin_options_type() == BuiltinOptions_BatchMatMulOptions
7847                ? static_cast<const BatchMatMulOptions *>(builtin_options())
7848                : nullptr;
7849   }
7850   const flatbuffers::Vector<uint8_t> *custom_options() const
7851   {
7852     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
7853   }
7854   CustomOptionsFormat custom_options_format() const
7855   {
7856     return static_cast<CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
7857   }
7858   const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const
7859   {
7860     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
7861   }
7862   const flatbuffers::Vector<int32_t> *intermediates() const
7863   {
7864     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
7865   }
7866   bool Verify(flatbuffers::Verifier &verifier) const
7867   {
7868     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
7869            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
7870            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
7871            VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
7872            VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
7873            VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
7874            VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && verifier.VerifyVector(custom_options()) &&
7875            VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
7876            VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
7877            verifier.VerifyVector(mutating_variable_inputs()) &&
7878            VerifyOffset(verifier, VT_INTERMEDIATES) && verifier.VerifyVector(intermediates()) &&
7879            verifier.EndTable();
7880   }
7881 };
7882
7883 template <> inline const Conv2DOptions *Operator::builtin_options_as<Conv2DOptions>() const
7884 {
7885   return builtin_options_as_Conv2DOptions();
7886 }
7887
7888 template <>
7889 inline const DepthwiseConv2DOptions *Operator::builtin_options_as<DepthwiseConv2DOptions>() const
7890 {
7891   return builtin_options_as_DepthwiseConv2DOptions();
7892 }
7893
7894 template <>
7895 inline const ConcatEmbeddingsOptions *Operator::builtin_options_as<ConcatEmbeddingsOptions>() const
7896 {
7897   return builtin_options_as_ConcatEmbeddingsOptions();
7898 }
7899
7900 template <>
7901 inline const LSHProjectionOptions *Operator::builtin_options_as<LSHProjectionOptions>() const
7902 {
7903   return builtin_options_as_LSHProjectionOptions();
7904 }
7905
7906 template <> inline const Pool2DOptions *Operator::builtin_options_as<Pool2DOptions>() const
7907 {
7908   return builtin_options_as_Pool2DOptions();
7909 }
7910
7911 template <> inline const SVDFOptions *Operator::builtin_options_as<SVDFOptions>() const
7912 {
7913   return builtin_options_as_SVDFOptions();
7914 }
7915
7916 template <> inline const RNNOptions *Operator::builtin_options_as<RNNOptions>() const
7917 {
7918   return builtin_options_as_RNNOptions();
7919 }
7920
7921 template <>
7922 inline const FullyConnectedOptions *Operator::builtin_options_as<FullyConnectedOptions>() const
7923 {
7924   return builtin_options_as_FullyConnectedOptions();
7925 }
7926
7927 template <> inline const SoftmaxOptions *Operator::builtin_options_as<SoftmaxOptions>() const
7928 {
7929   return builtin_options_as_SoftmaxOptions();
7930 }
7931
7932 template <>
7933 inline const ConcatenationOptions *Operator::builtin_options_as<ConcatenationOptions>() const
7934 {
7935   return builtin_options_as_ConcatenationOptions();
7936 }
7937
7938 template <> inline const AddOptions *Operator::builtin_options_as<AddOptions>() const
7939 {
7940   return builtin_options_as_AddOptions();
7941 }
7942
7943 template <> inline const L2NormOptions *Operator::builtin_options_as<L2NormOptions>() const
7944 {
7945   return builtin_options_as_L2NormOptions();
7946 }
7947
7948 template <>
7949 inline const LocalResponseNormalizationOptions *
7950 Operator::builtin_options_as<LocalResponseNormalizationOptions>() const
7951 {
7952   return builtin_options_as_LocalResponseNormalizationOptions();
7953 }
7954
7955 template <> inline const LSTMOptions *Operator::builtin_options_as<LSTMOptions>() const
7956 {
7957   return builtin_options_as_LSTMOptions();
7958 }
7959
7960 template <>
7961 inline const ResizeBilinearOptions *Operator::builtin_options_as<ResizeBilinearOptions>() const
7962 {
7963   return builtin_options_as_ResizeBilinearOptions();
7964 }
7965
7966 template <> inline const CallOptions *Operator::builtin_options_as<CallOptions>() const
7967 {
7968   return builtin_options_as_CallOptions();
7969 }
7970
7971 template <> inline const ReshapeOptions *Operator::builtin_options_as<ReshapeOptions>() const
7972 {
7973   return builtin_options_as_ReshapeOptions();
7974 }
7975
7976 template <> inline const SkipGramOptions *Operator::builtin_options_as<SkipGramOptions>() const
7977 {
7978   return builtin_options_as_SkipGramOptions();
7979 }
7980
7981 template <>
7982 inline const SpaceToDepthOptions *Operator::builtin_options_as<SpaceToDepthOptions>() const
7983 {
7984   return builtin_options_as_SpaceToDepthOptions();
7985 }
7986
7987 template <>
7988 inline const EmbeddingLookupSparseOptions *
7989 Operator::builtin_options_as<EmbeddingLookupSparseOptions>() const
7990 {
7991   return builtin_options_as_EmbeddingLookupSparseOptions();
7992 }
7993
7994 template <> inline const MulOptions *Operator::builtin_options_as<MulOptions>() const
7995 {
7996   return builtin_options_as_MulOptions();
7997 }
7998
7999 template <> inline const PadOptions *Operator::builtin_options_as<PadOptions>() const
8000 {
8001   return builtin_options_as_PadOptions();
8002 }
8003
8004 template <> inline const GatherOptions *Operator::builtin_options_as<GatherOptions>() const
8005 {
8006   return builtin_options_as_GatherOptions();
8007 }
8008
8009 template <>
8010 inline const BatchToSpaceNDOptions *Operator::builtin_options_as<BatchToSpaceNDOptions>() const
8011 {
8012   return builtin_options_as_BatchToSpaceNDOptions();
8013 }
8014
8015 template <>
8016 inline const SpaceToBatchNDOptions *Operator::builtin_options_as<SpaceToBatchNDOptions>() const
8017 {
8018   return builtin_options_as_SpaceToBatchNDOptions();
8019 }
8020
8021 template <> inline const TransposeOptions *Operator::builtin_options_as<TransposeOptions>() const
8022 {
8023   return builtin_options_as_TransposeOptions();
8024 }
8025
8026 template <> inline const ReducerOptions *Operator::builtin_options_as<ReducerOptions>() const
8027 {
8028   return builtin_options_as_ReducerOptions();
8029 }
8030
8031 template <> inline const SubOptions *Operator::builtin_options_as<SubOptions>() const
8032 {
8033   return builtin_options_as_SubOptions();
8034 }
8035
8036 template <> inline const DivOptions *Operator::builtin_options_as<DivOptions>() const
8037 {
8038   return builtin_options_as_DivOptions();
8039 }
8040
8041 template <> inline const SqueezeOptions *Operator::builtin_options_as<SqueezeOptions>() const
8042 {
8043   return builtin_options_as_SqueezeOptions();
8044 }
8045
8046 template <>
8047 inline const SequenceRNNOptions *Operator::builtin_options_as<SequenceRNNOptions>() const
8048 {
8049   return builtin_options_as_SequenceRNNOptions();
8050 }
8051
8052 template <>
8053 inline const StridedSliceOptions *Operator::builtin_options_as<StridedSliceOptions>() const
8054 {
8055   return builtin_options_as_StridedSliceOptions();
8056 }
8057
8058 template <> inline const ExpOptions *Operator::builtin_options_as<ExpOptions>() const
8059 {
8060   return builtin_options_as_ExpOptions();
8061 }
8062
8063 template <> inline const TopKV2Options *Operator::builtin_options_as<TopKV2Options>() const
8064 {
8065   return builtin_options_as_TopKV2Options();
8066 }
8067
8068 template <> inline const SplitOptions *Operator::builtin_options_as<SplitOptions>() const
8069 {
8070   return builtin_options_as_SplitOptions();
8071 }
8072
8073 template <> inline const LogSoftmaxOptions *Operator::builtin_options_as<LogSoftmaxOptions>() const
8074 {
8075   return builtin_options_as_LogSoftmaxOptions();
8076 }
8077
8078 template <> inline const CastOptions *Operator::builtin_options_as<CastOptions>() const
8079 {
8080   return builtin_options_as_CastOptions();
8081 }
8082
8083 template <> inline const DequantizeOptions *Operator::builtin_options_as<DequantizeOptions>() const
8084 {
8085   return builtin_options_as_DequantizeOptions();
8086 }
8087
8088 template <>
8089 inline const MaximumMinimumOptions *Operator::builtin_options_as<MaximumMinimumOptions>() const
8090 {
8091   return builtin_options_as_MaximumMinimumOptions();
8092 }
8093
8094 template <> inline const ArgMaxOptions *Operator::builtin_options_as<ArgMaxOptions>() const
8095 {
8096   return builtin_options_as_ArgMaxOptions();
8097 }
8098
8099 template <> inline const LessOptions *Operator::builtin_options_as<LessOptions>() const
8100 {
8101   return builtin_options_as_LessOptions();
8102 }
8103
8104 template <> inline const NegOptions *Operator::builtin_options_as<NegOptions>() const
8105 {
8106   return builtin_options_as_NegOptions();
8107 }
8108
8109 template <> inline const PadV2Options *Operator::builtin_options_as<PadV2Options>() const
8110 {
8111   return builtin_options_as_PadV2Options();
8112 }
8113
8114 template <> inline const GreaterOptions *Operator::builtin_options_as<GreaterOptions>() const
8115 {
8116   return builtin_options_as_GreaterOptions();
8117 }
8118
8119 template <>
8120 inline const GreaterEqualOptions *Operator::builtin_options_as<GreaterEqualOptions>() const
8121 {
8122   return builtin_options_as_GreaterEqualOptions();
8123 }
8124
8125 template <> inline const LessEqualOptions *Operator::builtin_options_as<LessEqualOptions>() const
8126 {
8127   return builtin_options_as_LessEqualOptions();
8128 }
8129
8130 template <> inline const SelectOptions *Operator::builtin_options_as<SelectOptions>() const
8131 {
8132   return builtin_options_as_SelectOptions();
8133 }
8134
8135 template <> inline const SliceOptions *Operator::builtin_options_as<SliceOptions>() const
8136 {
8137   return builtin_options_as_SliceOptions();
8138 }
8139
8140 template <>
8141 inline const TransposeConvOptions *Operator::builtin_options_as<TransposeConvOptions>() const
8142 {
8143   return builtin_options_as_TransposeConvOptions();
8144 }
8145
8146 template <>
8147 inline const SparseToDenseOptions *Operator::builtin_options_as<SparseToDenseOptions>() const
8148 {
8149   return builtin_options_as_SparseToDenseOptions();
8150 }
8151
8152 template <> inline const TileOptions *Operator::builtin_options_as<TileOptions>() const
8153 {
8154   return builtin_options_as_TileOptions();
8155 }
8156
8157 template <> inline const ExpandDimsOptions *Operator::builtin_options_as<ExpandDimsOptions>() const
8158 {
8159   return builtin_options_as_ExpandDimsOptions();
8160 }
8161
8162 template <> inline const EqualOptions *Operator::builtin_options_as<EqualOptions>() const
8163 {
8164   return builtin_options_as_EqualOptions();
8165 }
8166
8167 template <> inline const NotEqualOptions *Operator::builtin_options_as<NotEqualOptions>() const
8168 {
8169   return builtin_options_as_NotEqualOptions();
8170 }
8171
8172 template <> inline const ShapeOptions *Operator::builtin_options_as<ShapeOptions>() const
8173 {
8174   return builtin_options_as_ShapeOptions();
8175 }
8176
8177 template <> inline const PowOptions *Operator::builtin_options_as<PowOptions>() const
8178 {
8179   return builtin_options_as_PowOptions();
8180 }
8181
8182 template <> inline const ArgMinOptions *Operator::builtin_options_as<ArgMinOptions>() const
8183 {
8184   return builtin_options_as_ArgMinOptions();
8185 }
8186
8187 template <> inline const FakeQuantOptions *Operator::builtin_options_as<FakeQuantOptions>() const
8188 {
8189   return builtin_options_as_FakeQuantOptions();
8190 }
8191
8192 template <> inline const PackOptions *Operator::builtin_options_as<PackOptions>() const
8193 {
8194   return builtin_options_as_PackOptions();
8195 }
8196
8197 template <> inline const LogicalOrOptions *Operator::builtin_options_as<LogicalOrOptions>() const
8198 {
8199   return builtin_options_as_LogicalOrOptions();
8200 }
8201
8202 template <> inline const OneHotOptions *Operator::builtin_options_as<OneHotOptions>() const
8203 {
8204   return builtin_options_as_OneHotOptions();
8205 }
8206
8207 template <> inline const LogicalAndOptions *Operator::builtin_options_as<LogicalAndOptions>() const
8208 {
8209   return builtin_options_as_LogicalAndOptions();
8210 }
8211
8212 template <> inline const LogicalNotOptions *Operator::builtin_options_as<LogicalNotOptions>() const
8213 {
8214   return builtin_options_as_LogicalNotOptions();
8215 }
8216
8217 template <> inline const UnpackOptions *Operator::builtin_options_as<UnpackOptions>() const
8218 {
8219   return builtin_options_as_UnpackOptions();
8220 }
8221
8222 template <> inline const FloorDivOptions *Operator::builtin_options_as<FloorDivOptions>() const
8223 {
8224   return builtin_options_as_FloorDivOptions();
8225 }
8226
8227 template <> inline const SquareOptions *Operator::builtin_options_as<SquareOptions>() const
8228 {
8229   return builtin_options_as_SquareOptions();
8230 }
8231
8232 template <> inline const ZerosLikeOptions *Operator::builtin_options_as<ZerosLikeOptions>() const
8233 {
8234   return builtin_options_as_ZerosLikeOptions();
8235 }
8236
8237 template <> inline const FillOptions *Operator::builtin_options_as<FillOptions>() const
8238 {
8239   return builtin_options_as_FillOptions();
8240 }
8241
8242 template <>
8243 inline const BidirectionalSequenceLSTMOptions *
8244 Operator::builtin_options_as<BidirectionalSequenceLSTMOptions>() const
8245 {
8246   return builtin_options_as_BidirectionalSequenceLSTMOptions();
8247 }
8248
8249 template <>
8250 inline const BidirectionalSequenceRNNOptions *
8251 Operator::builtin_options_as<BidirectionalSequenceRNNOptions>() const
8252 {
8253   return builtin_options_as_BidirectionalSequenceRNNOptions();
8254 }
8255
8256 template <>
8257 inline const UnidirectionalSequenceLSTMOptions *
8258 Operator::builtin_options_as<UnidirectionalSequenceLSTMOptions>() const
8259 {
8260   return builtin_options_as_UnidirectionalSequenceLSTMOptions();
8261 }
8262
8263 template <> inline const FloorModOptions *Operator::builtin_options_as<FloorModOptions>() const
8264 {
8265   return builtin_options_as_FloorModOptions();
8266 }
8267
8268 template <> inline const RangeOptions *Operator::builtin_options_as<RangeOptions>() const
8269 {
8270   return builtin_options_as_RangeOptions();
8271 }
8272
8273 template <>
8274 inline const ResizeNearestNeighborOptions *
8275 Operator::builtin_options_as<ResizeNearestNeighborOptions>() const
8276 {
8277   return builtin_options_as_ResizeNearestNeighborOptions();
8278 }
8279
8280 template <> inline const LeakyReluOptions *Operator::builtin_options_as<LeakyReluOptions>() const
8281 {
8282   return builtin_options_as_LeakyReluOptions();
8283 }
8284
8285 template <>
8286 inline const SquaredDifferenceOptions *
8287 Operator::builtin_options_as<SquaredDifferenceOptions>() const
8288 {
8289   return builtin_options_as_SquaredDifferenceOptions();
8290 }
8291
8292 template <> inline const MirrorPadOptions *Operator::builtin_options_as<MirrorPadOptions>() const
8293 {
8294   return builtin_options_as_MirrorPadOptions();
8295 }
8296
8297 template <> inline const AbsOptions *Operator::builtin_options_as<AbsOptions>() const
8298 {
8299   return builtin_options_as_AbsOptions();
8300 }
8301
8302 template <> inline const SplitVOptions *Operator::builtin_options_as<SplitVOptions>() const
8303 {
8304   return builtin_options_as_SplitVOptions();
8305 }
8306
8307 template <> inline const UniqueOptions *Operator::builtin_options_as<UniqueOptions>() const
8308 {
8309   return builtin_options_as_UniqueOptions();
8310 }
8311
8312 template <> inline const ReverseV2Options *Operator::builtin_options_as<ReverseV2Options>() const
8313 {
8314   return builtin_options_as_ReverseV2Options();
8315 }
8316
8317 template <> inline const AddNOptions *Operator::builtin_options_as<AddNOptions>() const
8318 {
8319   return builtin_options_as_AddNOptions();
8320 }
8321
8322 template <> inline const GatherNdOptions *Operator::builtin_options_as<GatherNdOptions>() const
8323 {
8324   return builtin_options_as_GatherNdOptions();
8325 }
8326
8327 template <> inline const CosOptions *Operator::builtin_options_as<CosOptions>() const
8328 {
8329   return builtin_options_as_CosOptions();
8330 }
8331
8332 template <> inline const WhereOptions *Operator::builtin_options_as<WhereOptions>() const
8333 {
8334   return builtin_options_as_WhereOptions();
8335 }
8336
8337 template <> inline const RankOptions *Operator::builtin_options_as<RankOptions>() const
8338 {
8339   return builtin_options_as_RankOptions();
8340 }
8341
8342 template <>
8343 inline const ReverseSequenceOptions *Operator::builtin_options_as<ReverseSequenceOptions>() const
8344 {
8345   return builtin_options_as_ReverseSequenceOptions();
8346 }
8347
8348 template <> inline const MatrixDiagOptions *Operator::builtin_options_as<MatrixDiagOptions>() const
8349 {
8350   return builtin_options_as_MatrixDiagOptions();
8351 }
8352
8353 template <> inline const QuantizeOptions *Operator::builtin_options_as<QuantizeOptions>() const
8354 {
8355   return builtin_options_as_QuantizeOptions();
8356 }
8357
8358 template <>
8359 inline const MatrixSetDiagOptions *Operator::builtin_options_as<MatrixSetDiagOptions>() const
8360 {
8361   return builtin_options_as_MatrixSetDiagOptions();
8362 }
8363
8364 template <> inline const HardSwishOptions *Operator::builtin_options_as<HardSwishOptions>() const
8365 {
8366   return builtin_options_as_HardSwishOptions();
8367 }
8368
8369 template <> inline const IfOptions *Operator::builtin_options_as<IfOptions>() const
8370 {
8371   return builtin_options_as_IfOptions();
8372 }
8373
8374 template <> inline const WhileOptions *Operator::builtin_options_as<WhileOptions>() const
8375 {
8376   return builtin_options_as_WhileOptions();
8377 }
8378
8379 template <>
8380 inline const DepthToSpaceOptions *Operator::builtin_options_as<DepthToSpaceOptions>() const
8381 {
8382   return builtin_options_as_DepthToSpaceOptions();
8383 }
8384
8385 template <>
8386 inline const NonMaxSuppressionV4Options *
8387 Operator::builtin_options_as<NonMaxSuppressionV4Options>() const
8388 {
8389   return builtin_options_as_NonMaxSuppressionV4Options();
8390 }
8391
8392 template <>
8393 inline const NonMaxSuppressionV5Options *
8394 Operator::builtin_options_as<NonMaxSuppressionV5Options>() const
8395 {
8396   return builtin_options_as_NonMaxSuppressionV5Options();
8397 }
8398
8399 template <> inline const ScatterNdOptions *Operator::builtin_options_as<ScatterNdOptions>() const
8400 {
8401   return builtin_options_as_ScatterNdOptions();
8402 }
8403
8404 template <> inline const SelectV2Options *Operator::builtin_options_as<SelectV2Options>() const
8405 {
8406   return builtin_options_as_SelectV2Options();
8407 }
8408
8409 template <> inline const DensifyOptions *Operator::builtin_options_as<DensifyOptions>() const
8410 {
8411   return builtin_options_as_DensifyOptions();
8412 }
8413
8414 template <> inline const SegmentSumOptions *Operator::builtin_options_as<SegmentSumOptions>() const
8415 {
8416   return builtin_options_as_SegmentSumOptions();
8417 }
8418
8419 template <>
8420 inline const BatchMatMulOptions *Operator::builtin_options_as<BatchMatMulOptions>() const
8421 {
8422   return builtin_options_as_BatchMatMulOptions();
8423 }
8424
8425 struct OperatorBuilder
8426 {
8427   flatbuffers::FlatBufferBuilder &fbb_;
8428   flatbuffers::uoffset_t start_;
8429   void add_opcode_index(uint32_t opcode_index)
8430   {
8431     fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
8432   }
8433   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
8434   {
8435     fbb_.AddOffset(Operator::VT_INPUTS, inputs);
8436   }
8437   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
8438   {
8439     fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
8440   }
8441   void add_builtin_options_type(BuiltinOptions builtin_options_type)
8442   {
8443     fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE,
8444                              static_cast<uint8_t>(builtin_options_type), 0);
8445   }
8446   void add_builtin_options(flatbuffers::Offset<void> builtin_options)
8447   {
8448     fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
8449   }
8450   void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options)
8451   {
8452     fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
8453   }
8454   void add_custom_options_format(CustomOptionsFormat custom_options_format)
8455   {
8456     fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT,
8457                             static_cast<int8_t>(custom_options_format), 0);
8458   }
8459   void add_mutating_variable_inputs(
8460       flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs)
8461   {
8462     fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
8463   }
8464   void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates)
8465   {
8466     fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
8467   }
8468   explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8469   {
8470     start_ = fbb_.StartTable();
8471   }
8472   OperatorBuilder &operator=(const OperatorBuilder &);
8473   flatbuffers::Offset<Operator> Finish()
8474   {
8475     const auto end = fbb_.EndTable(start_);
8476     auto o = flatbuffers::Offset<Operator>(end);
8477     return o;
8478   }
8479 };
8480
8481 inline flatbuffers::Offset<Operator>
8482 CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
8483                flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
8484                flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
8485                BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
8486                flatbuffers::Offset<void> builtin_options = 0,
8487                flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
8488                CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS,
8489                flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
8490                flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0)
8491 {
8492   OperatorBuilder builder_(_fbb);
8493   builder_.add_intermediates(intermediates);
8494   builder_.add_mutating_variable_inputs(mutating_variable_inputs);
8495   builder_.add_custom_options(custom_options);
8496   builder_.add_builtin_options(builtin_options);
8497   builder_.add_outputs(outputs);
8498   builder_.add_inputs(inputs);
8499   builder_.add_opcode_index(opcode_index);
8500   builder_.add_custom_options_format(custom_options_format);
8501   builder_.add_builtin_options_type(builtin_options_type);
8502   return builder_.Finish();
8503 }
8504
8505 inline flatbuffers::Offset<Operator>
8506 CreateOperatorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
8507                      const std::vector<int32_t> *inputs = nullptr,
8508                      const std::vector<int32_t> *outputs = nullptr,
8509                      BuiltinOptions builtin_options_type = BuiltinOptions_NONE,
8510                      flatbuffers::Offset<void> builtin_options = 0,
8511                      const std::vector<uint8_t> *custom_options = nullptr,
8512                      CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS,
8513                      const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
8514                      const std::vector<int32_t> *intermediates = nullptr)
8515 {
8516   return onert_tflite::CreateOperator(
8517       _fbb, opcode_index, inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0,
8518       outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0, builtin_options_type, builtin_options,
8519       custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0, custom_options_format,
8520       mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0,
8521       intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0);
8522 }
8523
8524 struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8525 {
8526   enum
8527   {
8528     VT_TENSORS = 4,
8529     VT_INPUTS = 6,
8530     VT_OUTPUTS = 8,
8531     VT_OPERATORS = 10,
8532     VT_NAME = 12
8533   };
8534   const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *tensors() const
8535   {
8536     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *>(VT_TENSORS);
8537   }
8538   const flatbuffers::Vector<int32_t> *inputs() const
8539   {
8540     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
8541   }
8542   const flatbuffers::Vector<int32_t> *outputs() const
8543   {
8544     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
8545   }
8546   const flatbuffers::Vector<flatbuffers::Offset<Operator>> *operators() const
8547   {
8548     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Operator>> *>(VT_OPERATORS);
8549   }
8550   const flatbuffers::String *name() const
8551   {
8552     return GetPointer<const flatbuffers::String *>(VT_NAME);
8553   }
8554   bool Verify(flatbuffers::Verifier &verifier) const
8555   {
8556     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) &&
8557            verifier.VerifyVector(tensors()) && verifier.VerifyVectorOfTables(tensors()) &&
8558            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
8559            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
8560            VerifyOffset(verifier, VT_OPERATORS) && verifier.VerifyVector(operators()) &&
8561            verifier.VerifyVectorOfTables(operators()) && VerifyOffset(verifier, VT_NAME) &&
8562            verifier.VerifyString(name()) && verifier.EndTable();
8563   }
8564 };
8565
8566 struct SubGraphBuilder
8567 {
8568   flatbuffers::FlatBufferBuilder &fbb_;
8569   flatbuffers::uoffset_t start_;
8570   void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors)
8571   {
8572     fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
8573   }
8574   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
8575   {
8576     fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
8577   }
8578   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
8579   {
8580     fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
8581   }
8582   void
8583   add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators)
8584   {
8585     fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
8586   }
8587   void add_name(flatbuffers::Offset<flatbuffers::String> name)
8588   {
8589     fbb_.AddOffset(SubGraph::VT_NAME, name);
8590   }
8591   explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8592   {
8593     start_ = fbb_.StartTable();
8594   }
8595   SubGraphBuilder &operator=(const SubGraphBuilder &);
8596   flatbuffers::Offset<SubGraph> Finish()
8597   {
8598     const auto end = fbb_.EndTable(start_);
8599     auto o = flatbuffers::Offset<SubGraph>(end);
8600     return o;
8601   }
8602 };
8603
8604 inline flatbuffers::Offset<SubGraph> CreateSubGraph(
8605     flatbuffers::FlatBufferBuilder &_fbb,
8606     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors = 0,
8607     flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
8608     flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
8609     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators = 0,
8610     flatbuffers::Offset<flatbuffers::String> name = 0)
8611 {
8612   SubGraphBuilder builder_(_fbb);
8613   builder_.add_name(name);
8614   builder_.add_operators(operators);
8615   builder_.add_outputs(outputs);
8616   builder_.add_inputs(inputs);
8617   builder_.add_tensors(tensors);
8618   return builder_.Finish();
8619 }
8620
8621 inline flatbuffers::Offset<SubGraph>
8622 CreateSubGraphDirect(flatbuffers::FlatBufferBuilder &_fbb,
8623                      const std::vector<flatbuffers::Offset<Tensor>> *tensors = nullptr,
8624                      const std::vector<int32_t> *inputs = nullptr,
8625                      const std::vector<int32_t> *outputs = nullptr,
8626                      const std::vector<flatbuffers::Offset<Operator>> *operators = nullptr,
8627                      const char *name = nullptr)
8628 {
8629   return onert_tflite::CreateSubGraph(
8630       _fbb, tensors ? _fbb.CreateVector<flatbuffers::Offset<Tensor>>(*tensors) : 0,
8631       inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0,
8632       outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0,
8633       operators ? _fbb.CreateVector<flatbuffers::Offset<Operator>>(*operators) : 0,
8634       name ? _fbb.CreateString(name) : 0);
8635 }
8636
8637 struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8638 {
8639   enum
8640   {
8641     VT_DATA = 4
8642   };
8643   const flatbuffers::Vector<uint8_t> *data() const
8644   {
8645     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
8646   }
8647   bool Verify(flatbuffers::Verifier &verifier) const
8648   {
8649     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) &&
8650            verifier.VerifyVector(data()) && verifier.EndTable();
8651   }
8652 };
8653
8654 struct BufferBuilder
8655 {
8656   flatbuffers::FlatBufferBuilder &fbb_;
8657   flatbuffers::uoffset_t start_;
8658   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data)
8659   {
8660     fbb_.AddOffset(Buffer::VT_DATA, data);
8661   }
8662   explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8663   {
8664     start_ = fbb_.StartTable();
8665   }
8666   BufferBuilder &operator=(const BufferBuilder &);
8667   flatbuffers::Offset<Buffer> Finish()
8668   {
8669     const auto end = fbb_.EndTable(start_);
8670     auto o = flatbuffers::Offset<Buffer>(end);
8671     return o;
8672   }
8673 };
8674
8675 inline flatbuffers::Offset<Buffer>
8676 CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb,
8677              flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0)
8678 {
8679   BufferBuilder builder_(_fbb);
8680   builder_.add_data(data);
8681   return builder_.Finish();
8682 }
8683
8684 inline flatbuffers::Offset<Buffer> CreateBufferDirect(flatbuffers::FlatBufferBuilder &_fbb,
8685                                                       const std::vector<uint8_t> *data = nullptr)
8686 {
8687   return onert_tflite::CreateBuffer(_fbb, data ? _fbb.CreateVector<uint8_t>(*data) : 0);
8688 }
8689
8690 struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8691 {
8692   enum
8693   {
8694     VT_NAME = 4,
8695     VT_BUFFER = 6
8696   };
8697   const flatbuffers::String *name() const
8698   {
8699     return GetPointer<const flatbuffers::String *>(VT_NAME);
8700   }
8701   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
8702   bool Verify(flatbuffers::Verifier &verifier) const
8703   {
8704     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
8705            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_BUFFER) &&
8706            verifier.EndTable();
8707   }
8708 };
8709
8710 struct MetadataBuilder
8711 {
8712   flatbuffers::FlatBufferBuilder &fbb_;
8713   flatbuffers::uoffset_t start_;
8714   void add_name(flatbuffers::Offset<flatbuffers::String> name)
8715   {
8716     fbb_.AddOffset(Metadata::VT_NAME, name);
8717   }
8718   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0); }
8719   explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8720   {
8721     start_ = fbb_.StartTable();
8722   }
8723   MetadataBuilder &operator=(const MetadataBuilder &);
8724   flatbuffers::Offset<Metadata> Finish()
8725   {
8726     const auto end = fbb_.EndTable(start_);
8727     auto o = flatbuffers::Offset<Metadata>(end);
8728     return o;
8729   }
8730 };
8731
8732 inline flatbuffers::Offset<Metadata>
8733 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb,
8734                flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t buffer = 0)
8735 {
8736   MetadataBuilder builder_(_fbb);
8737   builder_.add_buffer(buffer);
8738   builder_.add_name(name);
8739   return builder_.Finish();
8740 }
8741
8742 inline flatbuffers::Offset<Metadata> CreateMetadataDirect(flatbuffers::FlatBufferBuilder &_fbb,
8743                                                           const char *name = nullptr,
8744                                                           uint32_t buffer = 0)
8745 {
8746   return onert_tflite::CreateMetadata(_fbb, name ? _fbb.CreateString(name) : 0, buffer);
8747 }
8748
8749 struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8750 {
8751   enum
8752   {
8753     VT_VERSION = 4,
8754     VT_OPERATOR_CODES = 6,
8755     VT_SUBGRAPHS = 8,
8756     VT_DESCRIPTION = 10,
8757     VT_BUFFERS = 12,
8758     VT_METADATA_BUFFER = 14,
8759     VT_METADATA = 16
8760   };
8761   uint32_t version() const { return GetField<uint32_t>(VT_VERSION, 0); }
8762   const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *operator_codes() const
8763   {
8764     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *>(
8765         VT_OPERATOR_CODES);
8766   }
8767   const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *subgraphs() const
8768   {
8769     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *>(VT_SUBGRAPHS);
8770   }
8771   const flatbuffers::String *description() const
8772   {
8773     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
8774   }
8775   const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *buffers() const
8776   {
8777     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *>(VT_BUFFERS);
8778   }
8779   const flatbuffers::Vector<int32_t> *metadata_buffer() const
8780   {
8781     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
8782   }
8783   const flatbuffers::Vector<flatbuffers::Offset<Metadata>> *metadata() const
8784   {
8785     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Metadata>> *>(VT_METADATA);
8786   }
8787   bool Verify(flatbuffers::Verifier &verifier) const
8788   {
8789     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_VERSION) &&
8790            VerifyOffset(verifier, VT_OPERATOR_CODES) && verifier.VerifyVector(operator_codes()) &&
8791            verifier.VerifyVectorOfTables(operator_codes()) &&
8792            VerifyOffset(verifier, VT_SUBGRAPHS) && verifier.VerifyVector(subgraphs()) &&
8793            verifier.VerifyVectorOfTables(subgraphs()) && VerifyOffset(verifier, VT_DESCRIPTION) &&
8794            verifier.VerifyString(description()) && VerifyOffset(verifier, VT_BUFFERS) &&
8795            verifier.VerifyVector(buffers()) && verifier.VerifyVectorOfTables(buffers()) &&
8796            VerifyOffset(verifier, VT_METADATA_BUFFER) && verifier.VerifyVector(metadata_buffer()) &&
8797            VerifyOffset(verifier, VT_METADATA) && verifier.VerifyVector(metadata()) &&
8798            verifier.VerifyVectorOfTables(metadata()) && verifier.EndTable();
8799   }
8800 };
8801
8802 struct ModelBuilder
8803 {
8804   flatbuffers::FlatBufferBuilder &fbb_;
8805   flatbuffers::uoffset_t start_;
8806   void add_version(uint32_t version) { fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0); }
8807   void add_operator_codes(
8808       flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes)
8809   {
8810     fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
8811   }
8812   void
8813   add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs)
8814   {
8815     fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
8816   }
8817   void add_description(flatbuffers::Offset<flatbuffers::String> description)
8818   {
8819     fbb_.AddOffset(Model::VT_DESCRIPTION, description);
8820   }
8821   void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers)
8822   {
8823     fbb_.AddOffset(Model::VT_BUFFERS, buffers);
8824   }
8825   void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer)
8826   {
8827     fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
8828   }
8829   void
8830   add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Metadata>>> metadata)
8831   {
8832     fbb_.AddOffset(Model::VT_METADATA, metadata);
8833   }
8834   explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8835   {
8836     start_ = fbb_.StartTable();
8837   }
8838   ModelBuilder &operator=(const ModelBuilder &);
8839   flatbuffers::Offset<Model> Finish()
8840   {
8841     const auto end = fbb_.EndTable(start_);
8842     auto o = flatbuffers::Offset<Model>(end);
8843     return o;
8844   }
8845 };
8846
8847 inline flatbuffers::Offset<Model> CreateModel(
8848     flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
8849     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes = 0,
8850     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs = 0,
8851     flatbuffers::Offset<flatbuffers::String> description = 0,
8852     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers = 0,
8853     flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
8854     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Metadata>>> metadata = 0)
8855 {
8856   ModelBuilder builder_(_fbb);
8857   builder_.add_metadata(metadata);
8858   builder_.add_metadata_buffer(metadata_buffer);
8859   builder_.add_buffers(buffers);
8860   builder_.add_description(description);
8861   builder_.add_subgraphs(subgraphs);
8862   builder_.add_operator_codes(operator_codes);
8863   builder_.add_version(version);
8864   return builder_.Finish();
8865 }
8866
8867 inline flatbuffers::Offset<Model>
8868 CreateModelDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
8869                   const std::vector<flatbuffers::Offset<OperatorCode>> *operator_codes = nullptr,
8870                   const std::vector<flatbuffers::Offset<SubGraph>> *subgraphs = nullptr,
8871                   const char *description = nullptr,
8872                   const std::vector<flatbuffers::Offset<Buffer>> *buffers = nullptr,
8873                   const std::vector<int32_t> *metadata_buffer = nullptr,
8874                   const std::vector<flatbuffers::Offset<Metadata>> *metadata = nullptr)
8875 {
8876   return onert_tflite::CreateModel(
8877       _fbb, version,
8878       operator_codes ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>>(*operator_codes) : 0,
8879       subgraphs ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>>(*subgraphs) : 0,
8880       description ? _fbb.CreateString(description) : 0,
8881       buffers ? _fbb.CreateVector<flatbuffers::Offset<Buffer>>(*buffers) : 0,
8882       metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0,
8883       metadata ? _fbb.CreateVector<flatbuffers::Offset<Metadata>>(*metadata) : 0);
8884 }
8885
8886 inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
8887                                       QuantizationDetails type)
8888 {
8889   switch (type)
8890   {
8891     case QuantizationDetails_NONE:
8892     {
8893       return true;
8894     }
8895     case QuantizationDetails_CustomQuantization:
8896     {
8897       auto ptr = reinterpret_cast<const CustomQuantization *>(obj);
8898       return verifier.VerifyTable(ptr);
8899     }
8900     default:
8901       return false;
8902   }
8903 }
8904
8905 inline bool
8906 VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
8907                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
8908                                 const flatbuffers::Vector<uint8_t> *types)
8909 {
8910   if (!values || !types)
8911     return !values && !types;
8912   if (values->size() != types->size())
8913     return false;
8914   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
8915   {
8916     if (!VerifyQuantizationDetails(verifier, values->Get(i),
8917                                    types->GetEnum<QuantizationDetails>(i)))
8918     {
8919       return false;
8920     }
8921   }
8922   return true;
8923 }
8924
8925 inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
8926                                     SparseIndexVector type)
8927 {
8928   switch (type)
8929   {
8930     case SparseIndexVector_NONE:
8931     {
8932       return true;
8933     }
8934     case SparseIndexVector_Int32Vector:
8935     {
8936       auto ptr = reinterpret_cast<const Int32Vector *>(obj);
8937       return verifier.VerifyTable(ptr);
8938     }
8939     case SparseIndexVector_Uint16Vector:
8940     {
8941       auto ptr = reinterpret_cast<const Uint16Vector *>(obj);
8942       return verifier.VerifyTable(ptr);
8943     }
8944     case SparseIndexVector_Uint8Vector:
8945     {
8946       auto ptr = reinterpret_cast<const Uint8Vector *>(obj);
8947       return verifier.VerifyTable(ptr);
8948     }
8949     default:
8950       return false;
8951   }
8952 }
8953
8954 inline bool
8955 VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
8956                               const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
8957                               const flatbuffers::Vector<uint8_t> *types)
8958 {
8959   if (!values || !types)
8960     return !values && !types;
8961   if (values->size() != types->size())
8962     return false;
8963   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
8964   {
8965     if (!VerifySparseIndexVector(verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i)))
8966     {
8967       return false;
8968     }
8969   }
8970   return true;
8971 }
8972
8973 inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj,
8974                                  BuiltinOptions type)
8975 {
8976   switch (type)
8977   {
8978     case BuiltinOptions_NONE:
8979     {
8980       return true;
8981     }
8982     case BuiltinOptions_Conv2DOptions:
8983     {
8984       auto ptr = reinterpret_cast<const Conv2DOptions *>(obj);
8985       return verifier.VerifyTable(ptr);
8986     }
8987     case BuiltinOptions_DepthwiseConv2DOptions:
8988     {
8989       auto ptr = reinterpret_cast<const DepthwiseConv2DOptions *>(obj);
8990       return verifier.VerifyTable(ptr);
8991     }
8992     case BuiltinOptions_ConcatEmbeddingsOptions:
8993     {
8994       auto ptr = reinterpret_cast<const ConcatEmbeddingsOptions *>(obj);
8995       return verifier.VerifyTable(ptr);
8996     }
8997     case BuiltinOptions_LSHProjectionOptions:
8998     {
8999       auto ptr = reinterpret_cast<const LSHProjectionOptions *>(obj);
9000       return verifier.VerifyTable(ptr);
9001     }
9002     case BuiltinOptions_Pool2DOptions:
9003     {
9004       auto ptr = reinterpret_cast<const Pool2DOptions *>(obj);
9005       return verifier.VerifyTable(ptr);
9006     }
9007     case BuiltinOptions_SVDFOptions:
9008     {
9009       auto ptr = reinterpret_cast<const SVDFOptions *>(obj);
9010       return verifier.VerifyTable(ptr);
9011     }
9012     case BuiltinOptions_RNNOptions:
9013     {
9014       auto ptr = reinterpret_cast<const RNNOptions *>(obj);
9015       return verifier.VerifyTable(ptr);
9016     }
9017     case BuiltinOptions_FullyConnectedOptions:
9018     {
9019       auto ptr = reinterpret_cast<const FullyConnectedOptions *>(obj);
9020       return verifier.VerifyTable(ptr);
9021     }
9022     case BuiltinOptions_SoftmaxOptions:
9023     {
9024       auto ptr = reinterpret_cast<const SoftmaxOptions *>(obj);
9025       return verifier.VerifyTable(ptr);
9026     }
9027     case BuiltinOptions_ConcatenationOptions:
9028     {
9029       auto ptr = reinterpret_cast<const ConcatenationOptions *>(obj);
9030       return verifier.VerifyTable(ptr);
9031     }
9032     case BuiltinOptions_AddOptions:
9033     {
9034       auto ptr = reinterpret_cast<const AddOptions *>(obj);
9035       return verifier.VerifyTable(ptr);
9036     }
9037     case BuiltinOptions_L2NormOptions:
9038     {
9039       auto ptr = reinterpret_cast<const L2NormOptions *>(obj);
9040       return verifier.VerifyTable(ptr);
9041     }
9042     case BuiltinOptions_LocalResponseNormalizationOptions:
9043     {
9044       auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj);
9045       return verifier.VerifyTable(ptr);
9046     }
9047     case BuiltinOptions_LSTMOptions:
9048     {
9049       auto ptr = reinterpret_cast<const LSTMOptions *>(obj);
9050       return verifier.VerifyTable(ptr);
9051     }
9052     case BuiltinOptions_ResizeBilinearOptions:
9053     {
9054       auto ptr = reinterpret_cast<const ResizeBilinearOptions *>(obj);
9055       return verifier.VerifyTable(ptr);
9056     }
9057     case BuiltinOptions_CallOptions:
9058     {
9059       auto ptr = reinterpret_cast<const CallOptions *>(obj);
9060       return verifier.VerifyTable(ptr);
9061     }
9062     case BuiltinOptions_ReshapeOptions:
9063     {
9064       auto ptr = reinterpret_cast<const ReshapeOptions *>(obj);
9065       return verifier.VerifyTable(ptr);
9066     }
9067     case BuiltinOptions_SkipGramOptions:
9068     {
9069       auto ptr = reinterpret_cast<const SkipGramOptions *>(obj);
9070       return verifier.VerifyTable(ptr);
9071     }
9072     case BuiltinOptions_SpaceToDepthOptions:
9073     {
9074       auto ptr = reinterpret_cast<const SpaceToDepthOptions *>(obj);
9075       return verifier.VerifyTable(ptr);
9076     }
9077     case BuiltinOptions_EmbeddingLookupSparseOptions:
9078     {
9079       auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptions *>(obj);
9080       return verifier.VerifyTable(ptr);
9081     }
9082     case BuiltinOptions_MulOptions:
9083     {
9084       auto ptr = reinterpret_cast<const MulOptions *>(obj);
9085       return verifier.VerifyTable(ptr);
9086     }
9087     case BuiltinOptions_PadOptions:
9088     {
9089       auto ptr = reinterpret_cast<const PadOptions *>(obj);
9090       return verifier.VerifyTable(ptr);
9091     }
9092     case BuiltinOptions_GatherOptions:
9093     {
9094       auto ptr = reinterpret_cast<const GatherOptions *>(obj);
9095       return verifier.VerifyTable(ptr);
9096     }
9097     case BuiltinOptions_BatchToSpaceNDOptions:
9098     {
9099       auto ptr = reinterpret_cast<const BatchToSpaceNDOptions *>(obj);
9100       return verifier.VerifyTable(ptr);
9101     }
9102     case BuiltinOptions_SpaceToBatchNDOptions:
9103     {
9104       auto ptr = reinterpret_cast<const SpaceToBatchNDOptions *>(obj);
9105       return verifier.VerifyTable(ptr);
9106     }
9107     case BuiltinOptions_TransposeOptions:
9108     {
9109       auto ptr = reinterpret_cast<const TransposeOptions *>(obj);
9110       return verifier.VerifyTable(ptr);
9111     }
9112     case BuiltinOptions_ReducerOptions:
9113     {
9114       auto ptr = reinterpret_cast<const ReducerOptions *>(obj);
9115       return verifier.VerifyTable(ptr);
9116     }
9117     case BuiltinOptions_SubOptions:
9118     {
9119       auto ptr = reinterpret_cast<const SubOptions *>(obj);
9120       return verifier.VerifyTable(ptr);
9121     }
9122     case BuiltinOptions_DivOptions:
9123     {
9124       auto ptr = reinterpret_cast<const DivOptions *>(obj);
9125       return verifier.VerifyTable(ptr);
9126     }
9127     case BuiltinOptions_SqueezeOptions:
9128     {
9129       auto ptr = reinterpret_cast<const SqueezeOptions *>(obj);
9130       return verifier.VerifyTable(ptr);
9131     }
9132     case BuiltinOptions_SequenceRNNOptions:
9133     {
9134       auto ptr = reinterpret_cast<const SequenceRNNOptions *>(obj);
9135       return verifier.VerifyTable(ptr);
9136     }
9137     case BuiltinOptions_StridedSliceOptions:
9138     {
9139       auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj);
9140       return verifier.VerifyTable(ptr);
9141     }
9142     case BuiltinOptions_ExpOptions:
9143     {
9144       auto ptr = reinterpret_cast<const ExpOptions *>(obj);
9145       return verifier.VerifyTable(ptr);
9146     }
9147     case BuiltinOptions_TopKV2Options:
9148     {
9149       auto ptr = reinterpret_cast<const TopKV2Options *>(obj);
9150       return verifier.VerifyTable(ptr);
9151     }
9152     case BuiltinOptions_SplitOptions:
9153     {
9154       auto ptr = reinterpret_cast<const SplitOptions *>(obj);
9155       return verifier.VerifyTable(ptr);
9156     }
9157     case BuiltinOptions_LogSoftmaxOptions:
9158     {
9159       auto ptr = reinterpret_cast<const LogSoftmaxOptions *>(obj);
9160       return verifier.VerifyTable(ptr);
9161     }
9162     case BuiltinOptions_CastOptions:
9163     {
9164       auto ptr = reinterpret_cast<const CastOptions *>(obj);
9165       return verifier.VerifyTable(ptr);
9166     }
9167     case BuiltinOptions_DequantizeOptions:
9168     {
9169       auto ptr = reinterpret_cast<const DequantizeOptions *>(obj);
9170       return verifier.VerifyTable(ptr);
9171     }
9172     case BuiltinOptions_MaximumMinimumOptions:
9173     {
9174       auto ptr = reinterpret_cast<const MaximumMinimumOptions *>(obj);
9175       return verifier.VerifyTable(ptr);
9176     }
9177     case BuiltinOptions_ArgMaxOptions:
9178     {
9179       auto ptr = reinterpret_cast<const ArgMaxOptions *>(obj);
9180       return verifier.VerifyTable(ptr);
9181     }
9182     case BuiltinOptions_LessOptions:
9183     {
9184       auto ptr = reinterpret_cast<const LessOptions *>(obj);
9185       return verifier.VerifyTable(ptr);
9186     }
9187     case BuiltinOptions_NegOptions:
9188     {
9189       auto ptr = reinterpret_cast<const NegOptions *>(obj);
9190       return verifier.VerifyTable(ptr);
9191     }
9192     case BuiltinOptions_PadV2Options:
9193     {
9194       auto ptr = reinterpret_cast<const PadV2Options *>(obj);
9195       return verifier.VerifyTable(ptr);
9196     }
9197     case BuiltinOptions_GreaterOptions:
9198     {
9199       auto ptr = reinterpret_cast<const GreaterOptions *>(obj);
9200       return verifier.VerifyTable(ptr);
9201     }
9202     case BuiltinOptions_GreaterEqualOptions:
9203     {
9204       auto ptr = reinterpret_cast<const GreaterEqualOptions *>(obj);
9205       return verifier.VerifyTable(ptr);
9206     }
9207     case BuiltinOptions_LessEqualOptions:
9208     {
9209       auto ptr = reinterpret_cast<const LessEqualOptions *>(obj);
9210       return verifier.VerifyTable(ptr);
9211     }
9212     case BuiltinOptions_SelectOptions:
9213     {
9214       auto ptr = reinterpret_cast<const SelectOptions *>(obj);
9215       return verifier.VerifyTable(ptr);
9216     }
9217     case BuiltinOptions_SliceOptions:
9218     {
9219       auto ptr = reinterpret_cast<const SliceOptions *>(obj);
9220       return verifier.VerifyTable(ptr);
9221     }
9222     case BuiltinOptions_TransposeConvOptions:
9223     {
9224       auto ptr = reinterpret_cast<const TransposeConvOptions *>(obj);
9225       return verifier.VerifyTable(ptr);
9226     }
9227     case BuiltinOptions_SparseToDenseOptions:
9228     {
9229       auto ptr = reinterpret_cast<const SparseToDenseOptions *>(obj);
9230       return verifier.VerifyTable(ptr);
9231     }
9232     case BuiltinOptions_TileOptions:
9233     {
9234       auto ptr = reinterpret_cast<const TileOptions *>(obj);
9235       return verifier.VerifyTable(ptr);
9236     }
9237     case BuiltinOptions_ExpandDimsOptions:
9238     {
9239       auto ptr = reinterpret_cast<const ExpandDimsOptions *>(obj);
9240       return verifier.VerifyTable(ptr);
9241     }
9242     case BuiltinOptions_EqualOptions:
9243     {
9244       auto ptr = reinterpret_cast<const EqualOptions *>(obj);
9245       return verifier.VerifyTable(ptr);
9246     }
9247     case BuiltinOptions_NotEqualOptions:
9248     {
9249       auto ptr = reinterpret_cast<const NotEqualOptions *>(obj);
9250       return verifier.VerifyTable(ptr);
9251     }
9252     case BuiltinOptions_ShapeOptions:
9253     {
9254       auto ptr = reinterpret_cast<const ShapeOptions *>(obj);
9255       return verifier.VerifyTable(ptr);
9256     }
9257     case BuiltinOptions_PowOptions:
9258     {
9259       auto ptr = reinterpret_cast<const PowOptions *>(obj);
9260       return verifier.VerifyTable(ptr);
9261     }
9262     case BuiltinOptions_ArgMinOptions:
9263     {
9264       auto ptr = reinterpret_cast<const ArgMinOptions *>(obj);
9265       return verifier.VerifyTable(ptr);
9266     }
9267     case BuiltinOptions_FakeQuantOptions:
9268     {
9269       auto ptr = reinterpret_cast<const FakeQuantOptions *>(obj);
9270       return verifier.VerifyTable(ptr);
9271     }
9272     case BuiltinOptions_PackOptions:
9273     {
9274       auto ptr = reinterpret_cast<const PackOptions *>(obj);
9275       return verifier.VerifyTable(ptr);
9276     }
9277     case BuiltinOptions_LogicalOrOptions:
9278     {
9279       auto ptr = reinterpret_cast<const LogicalOrOptions *>(obj);
9280       return verifier.VerifyTable(ptr);
9281     }
9282     case BuiltinOptions_OneHotOptions:
9283     {
9284       auto ptr = reinterpret_cast<const OneHotOptions *>(obj);
9285       return verifier.VerifyTable(ptr);
9286     }
9287     case BuiltinOptions_LogicalAndOptions:
9288     {
9289       auto ptr = reinterpret_cast<const LogicalAndOptions *>(obj);
9290       return verifier.VerifyTable(ptr);
9291     }
9292     case BuiltinOptions_LogicalNotOptions:
9293     {
9294       auto ptr = reinterpret_cast<const LogicalNotOptions *>(obj);
9295       return verifier.VerifyTable(ptr);
9296     }
9297     case BuiltinOptions_UnpackOptions:
9298     {
9299       auto ptr = reinterpret_cast<const UnpackOptions *>(obj);
9300       return verifier.VerifyTable(ptr);
9301     }
9302     case BuiltinOptions_FloorDivOptions:
9303     {
9304       auto ptr = reinterpret_cast<const FloorDivOptions *>(obj);
9305       return verifier.VerifyTable(ptr);
9306     }
9307     case BuiltinOptions_SquareOptions:
9308     {
9309       auto ptr = reinterpret_cast<const SquareOptions *>(obj);
9310       return verifier.VerifyTable(ptr);
9311     }
9312     case BuiltinOptions_ZerosLikeOptions:
9313     {
9314       auto ptr = reinterpret_cast<const ZerosLikeOptions *>(obj);
9315       return verifier.VerifyTable(ptr);
9316     }
9317     case BuiltinOptions_FillOptions:
9318     {
9319       auto ptr = reinterpret_cast<const FillOptions *>(obj);
9320       return verifier.VerifyTable(ptr);
9321     }
9322     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
9323     {
9324       auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptions *>(obj);
9325       return verifier.VerifyTable(ptr);
9326     }
9327     case BuiltinOptions_BidirectionalSequenceRNNOptions:
9328     {
9329       auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptions *>(obj);
9330       return verifier.VerifyTable(ptr);
9331     }
9332     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
9333     {
9334       auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptions *>(obj);
9335       return verifier.VerifyTable(ptr);
9336     }
9337     case BuiltinOptions_FloorModOptions:
9338     {
9339       auto ptr = reinterpret_cast<const FloorModOptions *>(obj);
9340       return verifier.VerifyTable(ptr);
9341     }
9342     case BuiltinOptions_RangeOptions:
9343     {
9344       auto ptr = reinterpret_cast<const RangeOptions *>(obj);
9345       return verifier.VerifyTable(ptr);
9346     }
9347     case BuiltinOptions_ResizeNearestNeighborOptions:
9348     {
9349       auto ptr = reinterpret_cast<const ResizeNearestNeighborOptions *>(obj);
9350       return verifier.VerifyTable(ptr);
9351     }
9352     case BuiltinOptions_LeakyReluOptions:
9353     {
9354       auto ptr = reinterpret_cast<const LeakyReluOptions *>(obj);
9355       return verifier.VerifyTable(ptr);
9356     }
9357     case BuiltinOptions_SquaredDifferenceOptions:
9358     {
9359       auto ptr = reinterpret_cast<const SquaredDifferenceOptions *>(obj);
9360       return verifier.VerifyTable(ptr);
9361     }
9362     case BuiltinOptions_MirrorPadOptions:
9363     {
9364       auto ptr = reinterpret_cast<const MirrorPadOptions *>(obj);
9365       return verifier.VerifyTable(ptr);
9366     }
9367     case BuiltinOptions_AbsOptions:
9368     {
9369       auto ptr = reinterpret_cast<const AbsOptions *>(obj);
9370       return verifier.VerifyTable(ptr);
9371     }
9372     case BuiltinOptions_SplitVOptions:
9373     {
9374       auto ptr = reinterpret_cast<const SplitVOptions *>(obj);
9375       return verifier.VerifyTable(ptr);
9376     }
9377     case BuiltinOptions_UniqueOptions:
9378     {
9379       auto ptr = reinterpret_cast<const UniqueOptions *>(obj);
9380       return verifier.VerifyTable(ptr);
9381     }
9382     case BuiltinOptions_ReverseV2Options:
9383     {
9384       auto ptr = reinterpret_cast<const ReverseV2Options *>(obj);
9385       return verifier.VerifyTable(ptr);
9386     }
9387     case BuiltinOptions_AddNOptions:
9388     {
9389       auto ptr = reinterpret_cast<const AddNOptions *>(obj);
9390       return verifier.VerifyTable(ptr);
9391     }
9392     case BuiltinOptions_GatherNdOptions:
9393     {
9394       auto ptr = reinterpret_cast<const GatherNdOptions *>(obj);
9395       return verifier.VerifyTable(ptr);
9396     }
9397     case BuiltinOptions_CosOptions:
9398     {
9399       auto ptr = reinterpret_cast<const CosOptions *>(obj);
9400       return verifier.VerifyTable(ptr);
9401     }
9402     case BuiltinOptions_WhereOptions:
9403     {
9404       auto ptr = reinterpret_cast<const WhereOptions *>(obj);
9405       return verifier.VerifyTable(ptr);
9406     }
9407     case BuiltinOptions_RankOptions:
9408     {
9409       auto ptr = reinterpret_cast<const RankOptions *>(obj);
9410       return verifier.VerifyTable(ptr);
9411     }
9412     case BuiltinOptions_ReverseSequenceOptions:
9413     {
9414       auto ptr = reinterpret_cast<const ReverseSequenceOptions *>(obj);
9415       return verifier.VerifyTable(ptr);
9416     }
9417     case BuiltinOptions_MatrixDiagOptions:
9418     {
9419       auto ptr = reinterpret_cast<const MatrixDiagOptions *>(obj);
9420       return verifier.VerifyTable(ptr);
9421     }
9422     case BuiltinOptions_QuantizeOptions:
9423     {
9424       auto ptr = reinterpret_cast<const QuantizeOptions *>(obj);
9425       return verifier.VerifyTable(ptr);
9426     }
9427     case BuiltinOptions_MatrixSetDiagOptions:
9428     {
9429       auto ptr = reinterpret_cast<const MatrixSetDiagOptions *>(obj);
9430       return verifier.VerifyTable(ptr);
9431     }
9432     case BuiltinOptions_HardSwishOptions:
9433     {
9434       auto ptr = reinterpret_cast<const HardSwishOptions *>(obj);
9435       return verifier.VerifyTable(ptr);
9436     }
9437     case BuiltinOptions_IfOptions:
9438     {
9439       auto ptr = reinterpret_cast<const IfOptions *>(obj);
9440       return verifier.VerifyTable(ptr);
9441     }
9442     case BuiltinOptions_WhileOptions:
9443     {
9444       auto ptr = reinterpret_cast<const WhileOptions *>(obj);
9445       return verifier.VerifyTable(ptr);
9446     }
9447     case BuiltinOptions_DepthToSpaceOptions:
9448     {
9449       auto ptr = reinterpret_cast<const DepthToSpaceOptions *>(obj);
9450       return verifier.VerifyTable(ptr);
9451     }
9452     case BuiltinOptions_NonMaxSuppressionV4Options:
9453     {
9454       auto ptr = reinterpret_cast<const NonMaxSuppressionV4Options *>(obj);
9455       return verifier.VerifyTable(ptr);
9456     }
9457     case BuiltinOptions_NonMaxSuppressionV5Options:
9458     {
9459       auto ptr = reinterpret_cast<const NonMaxSuppressionV5Options *>(obj);
9460       return verifier.VerifyTable(ptr);
9461     }
9462     case BuiltinOptions_ScatterNdOptions:
9463     {
9464       auto ptr = reinterpret_cast<const ScatterNdOptions *>(obj);
9465       return verifier.VerifyTable(ptr);
9466     }
9467     case BuiltinOptions_SelectV2Options:
9468     {
9469       auto ptr = reinterpret_cast<const SelectV2Options *>(obj);
9470       return verifier.VerifyTable(ptr);
9471     }
9472     case BuiltinOptions_DensifyOptions:
9473     {
9474       auto ptr = reinterpret_cast<const DensifyOptions *>(obj);
9475       return verifier.VerifyTable(ptr);
9476     }
9477     case BuiltinOptions_SegmentSumOptions:
9478     {
9479       auto ptr = reinterpret_cast<const SegmentSumOptions *>(obj);
9480       return verifier.VerifyTable(ptr);
9481     }
9482     case BuiltinOptions_BatchMatMulOptions:
9483     {
9484       auto ptr = reinterpret_cast<const BatchMatMulOptions *>(obj);
9485       return verifier.VerifyTable(ptr);
9486     }
9487     default:
9488       return false;
9489   }
9490 }
9491
9492 inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
9493                                        const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
9494                                        const flatbuffers::Vector<uint8_t> *types)
9495 {
9496   if (!values || !types)
9497     return !values && !types;
9498   if (values->size() != types->size())
9499     return false;
9500   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
9501   {
9502     if (!VerifyBuiltinOptions(verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i)))
9503     {
9504       return false;
9505     }
9506   }
9507   return true;
9508 }
9509
9510 inline const onert_tflite::Model *GetModel(const void *buf)
9511 {
9512   return flatbuffers::GetRoot<onert_tflite::Model>(buf);
9513 }
9514
9515 inline const onert_tflite::Model *GetSizePrefixedModel(const void *buf)
9516 {
9517   return flatbuffers::GetSizePrefixedRoot<onert_tflite::Model>(buf);
9518 }
9519
9520 inline const char *ModelIdentifier() { return "TFL3"; }
9521
9522 inline bool ModelBufferHasIdentifier(const void *buf)
9523 {
9524   return flatbuffers::BufferHasIdentifier(buf, ModelIdentifier());
9525 }
9526
9527 inline bool VerifyModelBuffer(flatbuffers::Verifier &verifier)
9528 {
9529   return verifier.VerifyBuffer<onert_tflite::Model>(ModelIdentifier());
9530 }
9531
9532 inline bool VerifySizePrefixedModelBuffer(flatbuffers::Verifier &verifier)
9533 {
9534   return verifier.VerifySizePrefixedBuffer<onert_tflite::Model>(ModelIdentifier());
9535 }
9536
9537 inline const char *ModelExtension() { return "tflite"; }
9538
9539 inline void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
9540                               flatbuffers::Offset<onert_tflite::Model> root)
9541 {
9542   fbb.Finish(root, ModelIdentifier());
9543 }
9544
9545 inline void FinishSizePrefixedModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
9546                                           flatbuffers::Offset<onert_tflite::Model> root)
9547 {
9548   fbb.FinishSizePrefixed(root, ModelIdentifier());
9549 }
9550
9551 } // namespace onert_tflite
9552
9553 #endif // FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_