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

   1 /*
   2  * Copyright (c) 2019-2023 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 // automatically generated by the FlatBuffers compiler, do not modify
  18
  19 #ifndef FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_
  20 #define FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_
  21
  22 #include "flatbuffers/flatbuffers.h"
  23
  24 namespace onert_tflite
  25 {
  26
  27 struct CustomQuantization;
  28 struct CustomQuantizationBuilder;
  29
  30 struct QuantizationParameters;
  31 struct QuantizationParametersBuilder;
  32
  33 struct Int32Vector;
  34 struct Int32VectorBuilder;
  35
  36 struct Uint16Vector;
  37 struct Uint16VectorBuilder;
  38
  39 struct Uint8Vector;
  40 struct Uint8VectorBuilder;
  41
  42 struct DimensionMetadata;
  43 struct DimensionMetadataBuilder;
  44
  45 struct SparsityParameters;
  46 struct SparsityParametersBuilder;
  47
  48 struct Tensor;
  49 struct TensorBuilder;
  50
  51 struct Conv2DOptions;
  52 struct Conv2DOptionsBuilder;
  53
  54 struct Conv3DOptions;
  55 struct Conv3DOptionsBuilder;
  56
  57 struct Pool2DOptions;
  58 struct Pool2DOptionsBuilder;
  59
  60 struct DepthwiseConv2DOptions;
  61 struct DepthwiseConv2DOptionsBuilder;
  62
  63 struct ConcatEmbeddingsOptions;
  64 struct ConcatEmbeddingsOptionsBuilder;
  65
  66 struct LSHProjectionOptions;
  67 struct LSHProjectionOptionsBuilder;
  68
  69 struct SVDFOptions;
  70 struct SVDFOptionsBuilder;
  71
  72 struct RNNOptions;
  73 struct RNNOptionsBuilder;
  74
  75 struct SequenceRNNOptions;
  76 struct SequenceRNNOptionsBuilder;
  77
  78 struct BidirectionalSequenceRNNOptions;
  79 struct BidirectionalSequenceRNNOptionsBuilder;
  80
  81 struct FullyConnectedOptions;
  82 struct FullyConnectedOptionsBuilder;
  83
  84 struct SoftmaxOptions;
  85 struct SoftmaxOptionsBuilder;
  86
  87 struct ConcatenationOptions;
  88 struct ConcatenationOptionsBuilder;
  89
  90 struct AddOptions;
  91 struct AddOptionsBuilder;
  92
  93 struct MulOptions;
  94 struct MulOptionsBuilder;
  95
  96 struct L2NormOptions;
  97 struct L2NormOptionsBuilder;
  98
  99 struct LocalResponseNormalizationOptions;
 100 struct LocalResponseNormalizationOptionsBuilder;
 101
 102 struct LSTMOptions;
 103 struct LSTMOptionsBuilder;
 104
 105 struct UnidirectionalSequenceLSTMOptions;
 106 struct UnidirectionalSequenceLSTMOptionsBuilder;
 107
 108 struct BidirectionalSequenceLSTMOptions;
 109 struct BidirectionalSequenceLSTMOptionsBuilder;
 110
 111 struct ResizeBilinearOptions;
 112 struct ResizeBilinearOptionsBuilder;
 113
 114 struct ResizeNearestNeighborOptions;
 115 struct ResizeNearestNeighborOptionsBuilder;
 116
 117 struct CallOptions;
 118 struct CallOptionsBuilder;
 119
 120 struct PadOptions;
 121 struct PadOptionsBuilder;
 122
 123 struct PadV2Options;
 124 struct PadV2OptionsBuilder;
 125
 126 struct ReshapeOptions;
 127 struct ReshapeOptionsBuilder;
 128
 129 struct SpaceToBatchNDOptions;
 130 struct SpaceToBatchNDOptionsBuilder;
 131
 132 struct BatchToSpaceNDOptions;
 133 struct BatchToSpaceNDOptionsBuilder;
 134
 135 struct SkipGramOptions;
 136 struct SkipGramOptionsBuilder;
 137
 138 struct SpaceToDepthOptions;
 139 struct SpaceToDepthOptionsBuilder;
 140
 141 struct DepthToSpaceOptions;
 142 struct DepthToSpaceOptionsBuilder;
 143
 144 struct SubOptions;
 145 struct SubOptionsBuilder;
 146
 147 struct DivOptions;
 148 struct DivOptionsBuilder;
 149
 150 struct TopKV2Options;
 151 struct TopKV2OptionsBuilder;
 152
 153 struct EmbeddingLookupSparseOptions;
 154 struct EmbeddingLookupSparseOptionsBuilder;
 155
 156 struct GatherOptions;
 157 struct GatherOptionsBuilder;
 158
 159 struct TransposeOptions;
 160 struct TransposeOptionsBuilder;
 161
 162 struct ExpOptions;
 163 struct ExpOptionsBuilder;
 164
 165 struct CosOptions;
 166 struct CosOptionsBuilder;
 167
 168 struct ReducerOptions;
 169 struct ReducerOptionsBuilder;
 170
 171 struct SqueezeOptions;
 172 struct SqueezeOptionsBuilder;
 173
 174 struct SplitOptions;
 175 struct SplitOptionsBuilder;
 176
 177 struct SplitVOptions;
 178 struct SplitVOptionsBuilder;
 179
 180 struct StridedSliceOptions;
 181 struct StridedSliceOptionsBuilder;
 182
 183 struct LogSoftmaxOptions;
 184 struct LogSoftmaxOptionsBuilder;
 185
 186 struct CastOptions;
 187 struct CastOptionsBuilder;
 188
 189 struct DequantizeOptions;
 190 struct DequantizeOptionsBuilder;
 191
 192 struct MaximumMinimumOptions;
 193 struct MaximumMinimumOptionsBuilder;
 194
 195 struct TileOptions;
 196 struct TileOptionsBuilder;
 197
 198 struct ArgMaxOptions;
 199 struct ArgMaxOptionsBuilder;
 200
 201 struct ArgMinOptions;
 202 struct ArgMinOptionsBuilder;
 203
 204 struct GreaterOptions;
 205 struct GreaterOptionsBuilder;
 206
 207 struct GreaterEqualOptions;
 208 struct GreaterEqualOptionsBuilder;
 209
 210 struct LessOptions;
 211 struct LessOptionsBuilder;
 212
 213 struct LessEqualOptions;
 214 struct LessEqualOptionsBuilder;
 215
 216 struct NegOptions;
 217 struct NegOptionsBuilder;
 218
 219 struct SelectOptions;
 220 struct SelectOptionsBuilder;
 221
 222 struct SliceOptions;
 223 struct SliceOptionsBuilder;
 224
 225 struct TransposeConvOptions;
 226 struct TransposeConvOptionsBuilder;
 227
 228 struct ExpandDimsOptions;
 229 struct ExpandDimsOptionsBuilder;
 230
 231 struct SparseToDenseOptions;
 232 struct SparseToDenseOptionsBuilder;
 233
 234 struct EqualOptions;
 235 struct EqualOptionsBuilder;
 236
 237 struct NotEqualOptions;
 238 struct NotEqualOptionsBuilder;
 239
 240 struct ShapeOptions;
 241 struct ShapeOptionsBuilder;
 242
 243 struct RankOptions;
 244 struct RankOptionsBuilder;
 245
 246 struct PowOptions;
 247 struct PowOptionsBuilder;
 248
 249 struct FakeQuantOptions;
 250 struct FakeQuantOptionsBuilder;
 251
 252 struct PackOptions;
 253 struct PackOptionsBuilder;
 254
 255 struct LogicalOrOptions;
 256 struct LogicalOrOptionsBuilder;
 257
 258 struct OneHotOptions;
 259 struct OneHotOptionsBuilder;
 260
 261 struct AbsOptions;
 262 struct AbsOptionsBuilder;
 263
 264 struct HardSwishOptions;
 265 struct HardSwishOptionsBuilder;
 266
 267 struct LogicalAndOptions;
 268 struct LogicalAndOptionsBuilder;
 269
 270 struct LogicalNotOptions;
 271 struct LogicalNotOptionsBuilder;
 272
 273 struct UnpackOptions;
 274 struct UnpackOptionsBuilder;
 275
 276 struct FloorDivOptions;
 277 struct FloorDivOptionsBuilder;
 278
 279 struct SquareOptions;
 280 struct SquareOptionsBuilder;
 281
 282 struct ZerosLikeOptions;
 283 struct ZerosLikeOptionsBuilder;
 284
 285 struct FillOptions;
 286 struct FillOptionsBuilder;
 287
 288 struct FloorModOptions;
 289 struct FloorModOptionsBuilder;
 290
 291 struct RangeOptions;
 292 struct RangeOptionsBuilder;
 293
 294 struct LeakyReluOptions;
 295 struct LeakyReluOptionsBuilder;
 296
 297 struct SquaredDifferenceOptions;
 298 struct SquaredDifferenceOptionsBuilder;
 299
 300 struct MirrorPadOptions;
 301 struct MirrorPadOptionsBuilder;
 302
 303 struct UniqueOptions;
 304 struct UniqueOptionsBuilder;
 305
 306 struct ReverseV2Options;
 307 struct ReverseV2OptionsBuilder;
 308
 309 struct AddNOptions;
 310 struct AddNOptionsBuilder;
 311
 312 struct GatherNdOptions;
 313 struct GatherNdOptionsBuilder;
 314
 315 struct WhereOptions;
 316 struct WhereOptionsBuilder;
 317
 318 struct ReverseSequenceOptions;
 319 struct ReverseSequenceOptionsBuilder;
 320
 321 struct MatrixDiagOptions;
 322 struct MatrixDiagOptionsBuilder;
 323
 324 struct QuantizeOptions;
 325 struct QuantizeOptionsBuilder;
 326
 327 struct MatrixSetDiagOptions;
 328 struct MatrixSetDiagOptionsBuilder;
 329
 330 struct IfOptions;
 331 struct IfOptionsBuilder;
 332
 333 struct CallOnceOptions;
 334 struct CallOnceOptionsBuilder;
 335
 336 struct WhileOptions;
 337 struct WhileOptionsBuilder;
 338
 339 struct NonMaxSuppressionV4Options;
 340 struct NonMaxSuppressionV4OptionsBuilder;
 341
 342 struct NonMaxSuppressionV5Options;
 343 struct NonMaxSuppressionV5OptionsBuilder;
 344
 345 struct ScatterNdOptions;
 346 struct ScatterNdOptionsBuilder;
 347
 348 struct SelectV2Options;
 349 struct SelectV2OptionsBuilder;
 350
 351 struct DensifyOptions;
 352 struct DensifyOptionsBuilder;
 353
 354 struct SegmentSumOptions;
 355 struct SegmentSumOptionsBuilder;
 356
 357 struct BatchMatMulOptions;
 358 struct BatchMatMulOptionsBuilder;
 359
 360 struct CumsumOptions;
 361 struct CumsumOptionsBuilder;
 362
 363 struct BroadcastToOptions;
 364 struct BroadcastToOptionsBuilder;
 365
 366 struct Rfft2dOptions;
 367 struct Rfft2dOptionsBuilder;
 368
 369 struct HashtableOptions;
 370 struct HashtableOptionsBuilder;
 371
 372 struct HashtableFindOptions;
 373 struct HashtableFindOptionsBuilder;
 374
 375 struct HashtableImportOptions;
 376 struct HashtableImportOptionsBuilder;
 377
 378 struct HashtableSizeOptions;
 379 struct HashtableSizeOptionsBuilder;
 380
 381 struct VarHandleOptions;
 382 struct VarHandleOptionsBuilder;
 383
 384 struct ReadVariableOptions;
 385 struct ReadVariableOptionsBuilder;
 386
 387 struct AssignVariableOptions;
 388 struct AssignVariableOptionsBuilder;
 389
 390 struct RandomOptions;
 391 struct RandomOptionsBuilder;
 392
 393 struct BucketizeOptions;
 394 struct BucketizeOptionsBuilder;
 395
 396 struct GeluOptions;
 397 struct GeluOptionsBuilder;
 398
 399 struct DynamicUpdateSliceOptions;
 400 struct DynamicUpdateSliceOptionsBuilder;
 401
 402 struct UnsortedSegmentProdOptions;
 403 struct UnsortedSegmentProdOptionsBuilder;
 404
 405 struct UnsortedSegmentMaxOptions;
 406 struct UnsortedSegmentMaxOptionsBuilder;
 407
 408 struct UnsortedSegmentSumOptions;
 409 struct UnsortedSegmentSumOptionsBuilder;
 410
 411 struct ATan2Options;
 412 struct ATan2OptionsBuilder;
 413
 414 struct OperatorCode;
 415 struct OperatorCodeBuilder;
 416
 417 struct Operator;
 418 struct OperatorBuilder;
 419
 420 struct SubGraph;
 421 struct SubGraphBuilder;
 422
 423 struct Buffer;
 424 struct BufferBuilder;
 425
 426 struct Metadata;
 427 struct MetadataBuilder;
 428
 429 struct TensorMap;
 430 struct TensorMapBuilder;
 431
 432 struct SignatureDef;
 433 struct SignatureDefBuilder;
 434
 435 struct Model;
 436 struct ModelBuilder;
 437
 438 enum TensorType : int8_t
 439 {
 440   TensorType_FLOAT32 = 0,
 441   TensorType_FLOAT16 = 1,
 442   TensorType_INT32 = 2,
 443   TensorType_UINT8 = 3,
 444   TensorType_INT64 = 4,
 445   TensorType_STRING = 5,
 446   TensorType_BOOL = 6,
 447   TensorType_INT16 = 7,
 448   TensorType_COMPLEX64 = 8,
 449   TensorType_INT8 = 9,
 450   TensorType_FLOAT64 = 10,
 451   TensorType_COMPLEX128 = 11,
 452   TensorType_UINT64 = 12,
 453   TensorType_RESOURCE = 13,
 454   TensorType_VARIANT = 14,
 455   TensorType_UINT32 = 15,
 456   TensorType_UINT16 = 16,
 457   TensorType_MIN = TensorType_FLOAT32,
 458   TensorType_MAX = TensorType_UINT16
 459 };
 460
 461 inline const TensorType (&EnumValuesTensorType())[17]
 462 {
 463   static const TensorType values[] = {
 464     TensorType_FLOAT32,   TensorType_FLOAT16,  TensorType_INT32,   TensorType_UINT8,
 465     TensorType_INT64,     TensorType_STRING,   TensorType_BOOL,    TensorType_INT16,
 466     TensorType_COMPLEX64, TensorType_INT8,     TensorType_FLOAT64, TensorType_COMPLEX128,
 467     TensorType_UINT64,    TensorType_RESOURCE, TensorType_VARIANT, TensorType_UINT32,
 468     TensorType_UINT16};
 469   return values;
 470 }
 471
 472 inline const char *const *EnumNamesTensorType()
 473 {
 474   static const char *const names[18] = {"FLOAT32", "FLOAT16",    "INT32",  "UINT8",     "INT64",
 475                                         "STRING",  "BOOL",       "INT16",  "COMPLEX64", "INT8",
 476                                         "FLOAT64", "COMPLEX128", "UINT64", "RESOURCE",  "VARIANT",
 477                                         "UINT32",  "UINT16",     nullptr};
 478   return names;
 479 }
 480
 481 inline const char *EnumNameTensorType(TensorType e)
 482 {
 483   if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT16))
 484     return "";
 485   const size_t index = static_cast<size_t>(e);
 486   return EnumNamesTensorType()[index];
 487 }
 488
 489 enum QuantizationDetails : uint8_t
 490 {
 491   QuantizationDetails_NONE = 0,
 492   QuantizationDetails_CustomQuantization = 1,
 493   QuantizationDetails_MIN = QuantizationDetails_NONE,
 494   QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
 495 };
 496
 497 inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2]
 498 {
 499   static const QuantizationDetails values[] = {QuantizationDetails_NONE,
 500                                                QuantizationDetails_CustomQuantization};
 501   return values;
 502 }
 503
 504 inline const char *const *EnumNamesQuantizationDetails()
 505 {
 506   static const char *const names[3] = {"NONE", "CustomQuantization", nullptr};
 507   return names;
 508 }
 509
 510 inline const char *EnumNameQuantizationDetails(QuantizationDetails e)
 511 {
 512   if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization))
 513     return "";
 514   const size_t index = static_cast<size_t>(e);
 515   return EnumNamesQuantizationDetails()[index];
 516 }
 517
 518 template <typename T> struct QuantizationDetailsTraits
 519 {
 520   static const QuantizationDetails enum_value = QuantizationDetails_NONE;
 521 };
 522
 523 template <> struct QuantizationDetailsTraits<onert_tflite::CustomQuantization>
 524 {
 525   static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
 526 };
 527
 528 bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
 529                                QuantizationDetails type);
 530 bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
 531                                      const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 532                                      const flatbuffers::Vector<uint8_t> *types);
 533
 534 enum DimensionType : int8_t
 535 {
 536   DimensionType_DENSE = 0,
 537   DimensionType_SPARSE_CSR = 1,
 538   DimensionType_MIN = DimensionType_DENSE,
 539   DimensionType_MAX = DimensionType_SPARSE_CSR
 540 };
 541
 542 inline const DimensionType (&EnumValuesDimensionType())[2]
 543 {
 544   static const DimensionType values[] = {DimensionType_DENSE, DimensionType_SPARSE_CSR};
 545   return values;
 546 }
 547
 548 inline const char *const *EnumNamesDimensionType()
 549 {
 550   static const char *const names[3] = {"DENSE", "SPARSE_CSR", nullptr};
 551   return names;
 552 }
 553
 554 inline const char *EnumNameDimensionType(DimensionType e)
 555 {
 556   if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR))
 557     return "";
 558   const size_t index = static_cast<size_t>(e);
 559   return EnumNamesDimensionType()[index];
 560 }
 561
 562 enum SparseIndexVector : uint8_t
 563 {
 564   SparseIndexVector_NONE = 0,
 565   SparseIndexVector_Int32Vector = 1,
 566   SparseIndexVector_Uint16Vector = 2,
 567   SparseIndexVector_Uint8Vector = 3,
 568   SparseIndexVector_MIN = SparseIndexVector_NONE,
 569   SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
 570 };
 571
 572 inline const SparseIndexVector (&EnumValuesSparseIndexVector())[4]
 573 {
 574   static const SparseIndexVector values[] = {SparseIndexVector_NONE, SparseIndexVector_Int32Vector,
 575                                              SparseIndexVector_Uint16Vector,
 576                                              SparseIndexVector_Uint8Vector};
 577   return values;
 578 }
 579
 580 inline const char *const *EnumNamesSparseIndexVector()
 581 {
 582   static const char *const names[5] = {"NONE", "Int32Vector", "Uint16Vector", "Uint8Vector",
 583                                        nullptr};
 584   return names;
 585 }
 586
 587 inline const char *EnumNameSparseIndexVector(SparseIndexVector e)
 588 {
 589   if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector))
 590     return "";
 591   const size_t index = static_cast<size_t>(e);
 592   return EnumNamesSparseIndexVector()[index];
 593 }
 594
 595 template <typename T> struct SparseIndexVectorTraits
 596 {
 597   static const SparseIndexVector enum_value = SparseIndexVector_NONE;
 598 };
 599
 600 template <> struct SparseIndexVectorTraits<onert_tflite::Int32Vector>
 601 {
 602   static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
 603 };
 604
 605 template <> struct SparseIndexVectorTraits<onert_tflite::Uint16Vector>
 606 {
 607   static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
 608 };
 609
 610 template <> struct SparseIndexVectorTraits<onert_tflite::Uint8Vector>
 611 {
 612   static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
 613 };
 614
 615 bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
 616                              SparseIndexVector type);
 617 bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
 618                                    const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 619                                    const flatbuffers::Vector<uint8_t> *types);
 620
 621 enum BuiltinOperator : int32_t
 622 {
 623   BuiltinOperator_ADD = 0,
 624   BuiltinOperator_AVERAGE_POOL_2D = 1,
 625   BuiltinOperator_CONCATENATION = 2,
 626   BuiltinOperator_CONV_2D = 3,
 627   BuiltinOperator_DEPTHWISE_CONV_2D = 4,
 628   BuiltinOperator_DEPTH_TO_SPACE = 5,
 629   BuiltinOperator_DEQUANTIZE = 6,
 630   BuiltinOperator_EMBEDDING_LOOKUP = 7,
 631   BuiltinOperator_FLOOR = 8,
 632   BuiltinOperator_FULLY_CONNECTED = 9,
 633   BuiltinOperator_HASHTABLE_LOOKUP = 10,
 634   BuiltinOperator_L2_NORMALIZATION = 11,
 635   BuiltinOperator_L2_POOL_2D = 12,
 636   BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13,
 637   BuiltinOperator_LOGISTIC = 14,
 638   BuiltinOperator_LSH_PROJECTION = 15,
 639   BuiltinOperator_LSTM = 16,
 640   BuiltinOperator_MAX_POOL_2D = 17,
 641   BuiltinOperator_MUL = 18,
 642   BuiltinOperator_RELU = 19,
 643   BuiltinOperator_RELU_N1_TO_1 = 20,
 644   BuiltinOperator_RELU6 = 21,
 645   BuiltinOperator_RESHAPE = 22,
 646   BuiltinOperator_RESIZE_BILINEAR = 23,
 647   BuiltinOperator_RNN = 24,
 648   BuiltinOperator_SOFTMAX = 25,
 649   BuiltinOperator_SPACE_TO_DEPTH = 26,
 650   BuiltinOperator_SVDF = 27,
 651   BuiltinOperator_TANH = 28,
 652   BuiltinOperator_CONCAT_EMBEDDINGS = 29,
 653   BuiltinOperator_SKIP_GRAM = 30,
 654   BuiltinOperator_CALL = 31,
 655   BuiltinOperator_CUSTOM = 32,
 656   BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33,
 657   BuiltinOperator_PAD = 34,
 658   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35,
 659   BuiltinOperator_GATHER = 36,
 660   BuiltinOperator_BATCH_TO_SPACE_ND = 37,
 661   BuiltinOperator_SPACE_TO_BATCH_ND = 38,
 662   BuiltinOperator_TRANSPOSE = 39,
 663   BuiltinOperator_MEAN = 40,
 664   BuiltinOperator_SUB = 41,
 665   BuiltinOperator_DIV = 42,
 666   BuiltinOperator_SQUEEZE = 43,
 667   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
 668   BuiltinOperator_STRIDED_SLICE = 45,
 669   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
 670   BuiltinOperator_EXP = 47,
 671   BuiltinOperator_TOPK_V2 = 48,
 672   BuiltinOperator_SPLIT = 49,
 673   BuiltinOperator_LOG_SOFTMAX = 50,
 674   BuiltinOperator_DELEGATE = 51,
 675   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52,
 676   BuiltinOperator_CAST = 53,
 677   BuiltinOperator_PRELU = 54,
 678   BuiltinOperator_MAXIMUM = 55,
 679   BuiltinOperator_ARG_MAX = 56,
 680   BuiltinOperator_MINIMUM = 57,
 681   BuiltinOperator_LESS = 58,
 682   BuiltinOperator_NEG = 59,
 683   BuiltinOperator_PADV2 = 60,
 684   BuiltinOperator_GREATER = 61,
 685   BuiltinOperator_GREATER_EQUAL = 62,
 686   BuiltinOperator_LESS_EQUAL = 63,
 687   BuiltinOperator_SELECT = 64,
 688   BuiltinOperator_SLICE = 65,
 689   BuiltinOperator_SIN = 66,
 690   BuiltinOperator_TRANSPOSE_CONV = 67,
 691   BuiltinOperator_SPARSE_TO_DENSE = 68,
 692   BuiltinOperator_TILE = 69,
 693   BuiltinOperator_EXPAND_DIMS = 70,
 694   BuiltinOperator_EQUAL = 71,
 695   BuiltinOperator_NOT_EQUAL = 72,
 696   BuiltinOperator_LOG = 73,
 697   BuiltinOperator_SUM = 74,
 698   BuiltinOperator_SQRT = 75,
 699   BuiltinOperator_RSQRT = 76,
 700   BuiltinOperator_SHAPE = 77,
 701   BuiltinOperator_POW = 78,
 702   BuiltinOperator_ARG_MIN = 79,
 703   BuiltinOperator_FAKE_QUANT = 80,
 704   BuiltinOperator_REDUCE_PROD = 81,
 705   BuiltinOperator_REDUCE_MAX = 82,
 706   BuiltinOperator_PACK = 83,
 707   BuiltinOperator_LOGICAL_OR = 84,
 708   BuiltinOperator_ONE_HOT = 85,
 709   BuiltinOperator_LOGICAL_AND = 86,
 710   BuiltinOperator_LOGICAL_NOT = 87,
 711   BuiltinOperator_UNPACK = 88,
 712   BuiltinOperator_REDUCE_MIN = 89,
 713   BuiltinOperator_FLOOR_DIV = 90,
 714   BuiltinOperator_REDUCE_ANY = 91,
 715   BuiltinOperator_SQUARE = 92,
 716   BuiltinOperator_ZEROS_LIKE = 93,
 717   BuiltinOperator_FILL = 94,
 718   BuiltinOperator_FLOOR_MOD = 95,
 719   BuiltinOperator_RANGE = 96,
 720   BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97,
 721   BuiltinOperator_LEAKY_RELU = 98,
 722   BuiltinOperator_SQUARED_DIFFERENCE = 99,
 723   BuiltinOperator_MIRROR_PAD = 100,
 724   BuiltinOperator_ABS = 101,
 725   BuiltinOperator_SPLIT_V = 102,
 726   BuiltinOperator_UNIQUE = 103,
 727   BuiltinOperator_CEIL = 104,
 728   BuiltinOperator_REVERSE_V2 = 105,
 729   BuiltinOperator_ADD_N = 106,
 730   BuiltinOperator_GATHER_ND = 107,
 731   BuiltinOperator_COS = 108,
 732   BuiltinOperator_WHERE = 109,
 733   BuiltinOperator_RANK = 110,
 734   BuiltinOperator_ELU = 111,
 735   BuiltinOperator_REVERSE_SEQUENCE = 112,
 736   BuiltinOperator_MATRIX_DIAG = 113,
 737   BuiltinOperator_QUANTIZE = 114,
 738   BuiltinOperator_MATRIX_SET_DIAG = 115,
 739   BuiltinOperator_ROUND = 116,
 740   BuiltinOperator_HARD_SWISH = 117,
 741   BuiltinOperator_IF = 118,
 742   BuiltinOperator_WHILE = 119,
 743   BuiltinOperator_NON_MAX_SUPPRESSION_V4 = 120,
 744   BuiltinOperator_NON_MAX_SUPPRESSION_V5 = 121,
 745   BuiltinOperator_SCATTER_ND = 122,
 746   BuiltinOperator_SELECT_V2 = 123,
 747   BuiltinOperator_DENSIFY = 124,
 748   BuiltinOperator_SEGMENT_SUM = 125,
 749   BuiltinOperator_BATCH_MATMUL = 126,
 750   BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES = 127,
 751   BuiltinOperator_CUMSUM = 128,
 752   BuiltinOperator_CALL_ONCE = 129,
 753   BuiltinOperator_BROADCAST_TO = 130,
 754   BuiltinOperator_RFFT2D = 131,
 755   BuiltinOperator_CONV_3D = 132,
 756   BuiltinOperator_IMAG = 133,
 757   BuiltinOperator_REAL = 134,
 758   BuiltinOperator_COMPLEX_ABS = 135,
 759   BuiltinOperator_HASHTABLE = 136,
 760   BuiltinOperator_HASHTABLE_FIND = 137,
 761   BuiltinOperator_HASHTABLE_IMPORT = 138,
 762   BuiltinOperator_HASHTABLE_SIZE = 139,
 763   BuiltinOperator_REDUCE_ALL = 140,
 764   BuiltinOperator_CONV_3D_TRANSPOSE = 141,
 765   BuiltinOperator_VAR_HANDLE = 142,
 766   BuiltinOperator_READ_VARIABLE = 143,
 767   BuiltinOperator_ASSIGN_VARIABLE = 144,
 768   BuiltinOperator_BROADCAST_ARGS = 145,
 769   BuiltinOperator_RANDOM_STANDARD_NORMAL = 146,
 770   BuiltinOperator_BUCKETIZE = 147,
 771   BuiltinOperator_RANDOM_UNIFORM = 148,
 772   BuiltinOperator_MULTINOMIAL = 149,
 773   BuiltinOperator_GELU = 150,
 774   BuiltinOperator_DYNAMIC_UPDATE_SLICE = 151,
 775   BuiltinOperator_RELU_0_TO_1 = 152,
 776   BuiltinOperator_UNSORTED_SEGMENT_PROD = 153,
 777   BuiltinOperator_UNSORTED_SEGMENT_MAX = 154,
 778   BuiltinOperator_UNSORTED_SEGMENT_SUM = 155,
 779   BuiltinOperator_ATAN2 = 156,
 780   BuiltinOperator_MIN = BuiltinOperator_ADD,
 781   BuiltinOperator_MAX = BuiltinOperator_ATAN2
 782 };
 783
 784 inline const BuiltinOperator (&EnumValuesBuiltinOperator())[157]
 785 {
 786   static const BuiltinOperator values[] = {BuiltinOperator_ADD,
 787                                            BuiltinOperator_AVERAGE_POOL_2D,
 788                                            BuiltinOperator_CONCATENATION,
 789                                            BuiltinOperator_CONV_2D,
 790                                            BuiltinOperator_DEPTHWISE_CONV_2D,
 791                                            BuiltinOperator_DEPTH_TO_SPACE,
 792                                            BuiltinOperator_DEQUANTIZE,
 793                                            BuiltinOperator_EMBEDDING_LOOKUP,
 794                                            BuiltinOperator_FLOOR,
 795                                            BuiltinOperator_FULLY_CONNECTED,
 796                                            BuiltinOperator_HASHTABLE_LOOKUP,
 797                                            BuiltinOperator_L2_NORMALIZATION,
 798                                            BuiltinOperator_L2_POOL_2D,
 799                                            BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
 800                                            BuiltinOperator_LOGISTIC,
 801                                            BuiltinOperator_LSH_PROJECTION,
 802                                            BuiltinOperator_LSTM,
 803                                            BuiltinOperator_MAX_POOL_2D,
 804                                            BuiltinOperator_MUL,
 805                                            BuiltinOperator_RELU,
 806                                            BuiltinOperator_RELU_N1_TO_1,
 807                                            BuiltinOperator_RELU6,
 808                                            BuiltinOperator_RESHAPE,
 809                                            BuiltinOperator_RESIZE_BILINEAR,
 810                                            BuiltinOperator_RNN,
 811                                            BuiltinOperator_SOFTMAX,
 812                                            BuiltinOperator_SPACE_TO_DEPTH,
 813                                            BuiltinOperator_SVDF,
 814                                            BuiltinOperator_TANH,
 815                                            BuiltinOperator_CONCAT_EMBEDDINGS,
 816                                            BuiltinOperator_SKIP_GRAM,
 817                                            BuiltinOperator_CALL,
 818                                            BuiltinOperator_CUSTOM,
 819                                            BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
 820                                            BuiltinOperator_PAD,
 821                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
 822                                            BuiltinOperator_GATHER,
 823                                            BuiltinOperator_BATCH_TO_SPACE_ND,
 824                                            BuiltinOperator_SPACE_TO_BATCH_ND,
 825                                            BuiltinOperator_TRANSPOSE,
 826                                            BuiltinOperator_MEAN,
 827                                            BuiltinOperator_SUB,
 828                                            BuiltinOperator_DIV,
 829                                            BuiltinOperator_SQUEEZE,
 830                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
 831                                            BuiltinOperator_STRIDED_SLICE,
 832                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
 833                                            BuiltinOperator_EXP,
 834                                            BuiltinOperator_TOPK_V2,
 835                                            BuiltinOperator_SPLIT,
 836                                            BuiltinOperator_LOG_SOFTMAX,
 837                                            BuiltinOperator_DELEGATE,
 838                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
 839                                            BuiltinOperator_CAST,
 840                                            BuiltinOperator_PRELU,
 841                                            BuiltinOperator_MAXIMUM,
 842                                            BuiltinOperator_ARG_MAX,
 843                                            BuiltinOperator_MINIMUM,
 844                                            BuiltinOperator_LESS,
 845                                            BuiltinOperator_NEG,
 846                                            BuiltinOperator_PADV2,
 847                                            BuiltinOperator_GREATER,
 848                                            BuiltinOperator_GREATER_EQUAL,
 849                                            BuiltinOperator_LESS_EQUAL,
 850                                            BuiltinOperator_SELECT,
 851                                            BuiltinOperator_SLICE,
 852                                            BuiltinOperator_SIN,
 853                                            BuiltinOperator_TRANSPOSE_CONV,
 854                                            BuiltinOperator_SPARSE_TO_DENSE,
 855                                            BuiltinOperator_TILE,
 856                                            BuiltinOperator_EXPAND_DIMS,
 857                                            BuiltinOperator_EQUAL,
 858                                            BuiltinOperator_NOT_EQUAL,
 859                                            BuiltinOperator_LOG,
 860                                            BuiltinOperator_SUM,
 861                                            BuiltinOperator_SQRT,
 862                                            BuiltinOperator_RSQRT,
 863                                            BuiltinOperator_SHAPE,
 864                                            BuiltinOperator_POW,
 865                                            BuiltinOperator_ARG_MIN,
 866                                            BuiltinOperator_FAKE_QUANT,
 867                                            BuiltinOperator_REDUCE_PROD,
 868                                            BuiltinOperator_REDUCE_MAX,
 869                                            BuiltinOperator_PACK,
 870                                            BuiltinOperator_LOGICAL_OR,
 871                                            BuiltinOperator_ONE_HOT,
 872                                            BuiltinOperator_LOGICAL_AND,
 873                                            BuiltinOperator_LOGICAL_NOT,
 874                                            BuiltinOperator_UNPACK,
 875                                            BuiltinOperator_REDUCE_MIN,
 876                                            BuiltinOperator_FLOOR_DIV,
 877                                            BuiltinOperator_REDUCE_ANY,
 878                                            BuiltinOperator_SQUARE,
 879                                            BuiltinOperator_ZEROS_LIKE,
 880                                            BuiltinOperator_FILL,
 881                                            BuiltinOperator_FLOOR_MOD,
 882                                            BuiltinOperator_RANGE,
 883                                            BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
 884                                            BuiltinOperator_LEAKY_RELU,
 885                                            BuiltinOperator_SQUARED_DIFFERENCE,
 886                                            BuiltinOperator_MIRROR_PAD,
 887                                            BuiltinOperator_ABS,
 888                                            BuiltinOperator_SPLIT_V,
 889                                            BuiltinOperator_UNIQUE,
 890                                            BuiltinOperator_CEIL,
 891                                            BuiltinOperator_REVERSE_V2,
 892                                            BuiltinOperator_ADD_N,
 893                                            BuiltinOperator_GATHER_ND,
 894                                            BuiltinOperator_COS,
 895                                            BuiltinOperator_WHERE,
 896                                            BuiltinOperator_RANK,
 897                                            BuiltinOperator_ELU,
 898                                            BuiltinOperator_REVERSE_SEQUENCE,
 899                                            BuiltinOperator_MATRIX_DIAG,
 900                                            BuiltinOperator_QUANTIZE,
 901                                            BuiltinOperator_MATRIX_SET_DIAG,
 902                                            BuiltinOperator_ROUND,
 903                                            BuiltinOperator_HARD_SWISH,
 904                                            BuiltinOperator_IF,
 905                                            BuiltinOperator_WHILE,
 906                                            BuiltinOperator_NON_MAX_SUPPRESSION_V4,
 907                                            BuiltinOperator_NON_MAX_SUPPRESSION_V5,
 908                                            BuiltinOperator_SCATTER_ND,
 909                                            BuiltinOperator_SELECT_V2,
 910                                            BuiltinOperator_DENSIFY,
 911                                            BuiltinOperator_SEGMENT_SUM,
 912                                            BuiltinOperator_BATCH_MATMUL,
 913                                            BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES,
 914                                            BuiltinOperator_CUMSUM,
 915                                            BuiltinOperator_CALL_ONCE,
 916                                            BuiltinOperator_BROADCAST_TO,
 917                                            BuiltinOperator_RFFT2D,
 918                                            BuiltinOperator_CONV_3D,
 919                                            BuiltinOperator_IMAG,
 920                                            BuiltinOperator_REAL,
 921                                            BuiltinOperator_COMPLEX_ABS,
 922                                            BuiltinOperator_HASHTABLE,
 923                                            BuiltinOperator_HASHTABLE_FIND,
 924                                            BuiltinOperator_HASHTABLE_IMPORT,
 925                                            BuiltinOperator_HASHTABLE_SIZE,
 926                                            BuiltinOperator_REDUCE_ALL,
 927                                            BuiltinOperator_CONV_3D_TRANSPOSE,
 928                                            BuiltinOperator_VAR_HANDLE,
 929                                            BuiltinOperator_READ_VARIABLE,
 930                                            BuiltinOperator_ASSIGN_VARIABLE,
 931                                            BuiltinOperator_BROADCAST_ARGS,
 932                                            BuiltinOperator_RANDOM_STANDARD_NORMAL,
 933                                            BuiltinOperator_BUCKETIZE,
 934                                            BuiltinOperator_RANDOM_UNIFORM,
 935                                            BuiltinOperator_MULTINOMIAL,
 936                                            BuiltinOperator_GELU,
 937                                            BuiltinOperator_DYNAMIC_UPDATE_SLICE,
 938                                            BuiltinOperator_RELU_0_TO_1,
 939                                            BuiltinOperator_UNSORTED_SEGMENT_PROD,
 940                                            BuiltinOperator_UNSORTED_SEGMENT_MAX,
 941                                            BuiltinOperator_UNSORTED_SEGMENT_SUM,
 942                                            BuiltinOperator_ATAN2};
 943   return values;
 944 }
 945
 946 inline const char *const *EnumNamesBuiltinOperator()
 947 {
 948   static const char *const names[158] = {"ADD",
 949                                          "AVERAGE_POOL_2D",
 950                                          "CONCATENATION",
 951                                          "CONV_2D",
 952                                          "DEPTHWISE_CONV_2D",
 953                                          "DEPTH_TO_SPACE",
 954                                          "DEQUANTIZE",
 955                                          "EMBEDDING_LOOKUP",
 956                                          "FLOOR",
 957                                          "FULLY_CONNECTED",
 958                                          "HASHTABLE_LOOKUP",
 959                                          "L2_NORMALIZATION",
 960                                          "L2_POOL_2D",
 961                                          "LOCAL_RESPONSE_NORMALIZATION",
 962                                          "LOGISTIC",
 963                                          "LSH_PROJECTION",
 964                                          "LSTM",
 965                                          "MAX_POOL_2D",
 966                                          "MUL",
 967                                          "RELU",
 968                                          "RELU_N1_TO_1",
 969                                          "RELU6",
 970                                          "RESHAPE",
 971                                          "RESIZE_BILINEAR",
 972                                          "RNN",
 973                                          "SOFTMAX",
 974                                          "SPACE_TO_DEPTH",
 975                                          "SVDF",
 976                                          "TANH",
 977                                          "CONCAT_EMBEDDINGS",
 978                                          "SKIP_GRAM",
 979                                          "CALL",
 980                                          "CUSTOM",
 981                                          "EMBEDDING_LOOKUP_SPARSE",
 982                                          "PAD",
 983                                          "UNIDIRECTIONAL_SEQUENCE_RNN",
 984                                          "GATHER",
 985                                          "BATCH_TO_SPACE_ND",
 986                                          "SPACE_TO_BATCH_ND",
 987                                          "TRANSPOSE",
 988                                          "MEAN",
 989                                          "SUB",
 990                                          "DIV",
 991                                          "SQUEEZE",
 992                                          "UNIDIRECTIONAL_SEQUENCE_LSTM",
 993                                          "STRIDED_SLICE",
 994                                          "BIDIRECTIONAL_SEQUENCE_RNN",
 995                                          "EXP",
 996                                          "TOPK_V2",
 997                                          "SPLIT",
 998                                          "LOG_SOFTMAX",
 999                                          "DELEGATE",
1000                                          "BIDIRECTIONAL_SEQUENCE_LSTM",
1001                                          "CAST",
1002                                          "PRELU",
1003                                          "MAXIMUM",
1004                                          "ARG_MAX",
1005                                          "MINIMUM",
1006                                          "LESS",
1007                                          "NEG",
1008                                          "PADV2",
1009                                          "GREATER",
1010                                          "GREATER_EQUAL",
1011                                          "LESS_EQUAL",
1012                                          "SELECT",
1013                                          "SLICE",
1014                                          "SIN",
1015                                          "TRANSPOSE_CONV",
1016                                          "SPARSE_TO_DENSE",
1017                                          "TILE",
1018                                          "EXPAND_DIMS",
1019                                          "EQUAL",
1020                                          "NOT_EQUAL",
1021                                          "LOG",
1022                                          "SUM",
1023                                          "SQRT",
1024                                          "RSQRT",
1025                                          "SHAPE",
1026                                          "POW",
1027                                          "ARG_MIN",
1028                                          "FAKE_QUANT",
1029                                          "REDUCE_PROD",
1030                                          "REDUCE_MAX",
1031                                          "PACK",
1032                                          "LOGICAL_OR",
1033                                          "ONE_HOT",
1034                                          "LOGICAL_AND",
1035                                          "LOGICAL_NOT",
1036                                          "UNPACK",
1037                                          "REDUCE_MIN",
1038                                          "FLOOR_DIV",
1039                                          "REDUCE_ANY",
1040                                          "SQUARE",
1041                                          "ZEROS_LIKE",
1042                                          "FILL",
1043                                          "FLOOR_MOD",
1044                                          "RANGE",
1045                                          "RESIZE_NEAREST_NEIGHBOR",
1046                                          "LEAKY_RELU",
1047                                          "SQUARED_DIFFERENCE",
1048                                          "MIRROR_PAD",
1049                                          "ABS",
1050                                          "SPLIT_V",
1051                                          "UNIQUE",
1052                                          "CEIL",
1053                                          "REVERSE_V2",
1054                                          "ADD_N",
1055                                          "GATHER_ND",
1056                                          "COS",
1057                                          "WHERE",
1058                                          "RANK",
1059                                          "ELU",
1060                                          "REVERSE_SEQUENCE",
1061                                          "MATRIX_DIAG",
1062                                          "QUANTIZE",
1063                                          "MATRIX_SET_DIAG",
1064                                          "ROUND",
1065                                          "HARD_SWISH",
1066                                          "IF",
1067                                          "WHILE",
1068                                          "NON_MAX_SUPPRESSION_V4",
1069                                          "NON_MAX_SUPPRESSION_V5",
1070                                          "SCATTER_ND",
1071                                          "SELECT_V2",
1072                                          "DENSIFY",
1073                                          "SEGMENT_SUM",
1074                                          "BATCH_MATMUL",
1075                                          "PLACEHOLDER_FOR_GREATER_OP_CODES",
1076                                          "CUMSUM",
1077                                          "CALL_ONCE",
1078                                          "BROADCAST_TO",
1079                                          "RFFT2D",
1080                                          "CONV_3D",
1081                                          "IMAG",
1082                                          "REAL",
1083                                          "COMPLEX_ABS",
1084                                          "HASHTABLE",
1085                                          "HASHTABLE_FIND",
1086                                          "HASHTABLE_IMPORT",
1087                                          "HASHTABLE_SIZE",
1088                                          "REDUCE_ALL",
1089                                          "CONV_3D_TRANSPOSE",
1090                                          "VAR_HANDLE",
1091                                          "READ_VARIABLE",
1092                                          "ASSIGN_VARIABLE",
1093                                          "BROADCAST_ARGS",
1094                                          "RANDOM_STANDARD_NORMAL",
1095                                          "BUCKETIZE",
1096                                          "RANDOM_UNIFORM",
1097                                          "MULTINOMIAL",
1098                                          "GELU",
1099                                          "DYNAMIC_UPDATE_SLICE",
1100                                          "RELU_0_TO_1",
1101                                          "UNSORTED_SEGMENT_PROD",
1102                                          "UNSORTED_SEGMENT_MAX",
1103                                          "UNSORTED_SEGMENT_SUM",
1104                                          "ATAN2",
1105                                          nullptr};
1106   return names;
1107 }
1108
1109 inline const char *EnumNameBuiltinOperator(BuiltinOperator e)
1110 {
1111   if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_ATAN2))
1112     return "";
1113   const size_t index = static_cast<size_t>(e);
1114   return EnumNamesBuiltinOperator()[index];
1115 }
1116
1117 enum BuiltinOptions : uint8_t
1118 {
1119   BuiltinOptions_NONE = 0,
1120   BuiltinOptions_Conv2DOptions = 1,
1121   BuiltinOptions_DepthwiseConv2DOptions = 2,
1122   BuiltinOptions_ConcatEmbeddingsOptions = 3,
1123   BuiltinOptions_LSHProjectionOptions = 4,
1124   BuiltinOptions_Pool2DOptions = 5,
1125   BuiltinOptions_SVDFOptions = 6,
1126   BuiltinOptions_RNNOptions = 7,
1127   BuiltinOptions_FullyConnectedOptions = 8,
1128   BuiltinOptions_SoftmaxOptions = 9,
1129   BuiltinOptions_ConcatenationOptions = 10,
1130   BuiltinOptions_AddOptions = 11,
1131   BuiltinOptions_L2NormOptions = 12,
1132   BuiltinOptions_LocalResponseNormalizationOptions = 13,
1133   BuiltinOptions_LSTMOptions = 14,
1134   BuiltinOptions_ResizeBilinearOptions = 15,
1135   BuiltinOptions_CallOptions = 16,
1136   BuiltinOptions_ReshapeOptions = 17,
1137   BuiltinOptions_SkipGramOptions = 18,
1138   BuiltinOptions_SpaceToDepthOptions = 19,
1139   BuiltinOptions_EmbeddingLookupSparseOptions = 20,
1140   BuiltinOptions_MulOptions = 21,
1141   BuiltinOptions_PadOptions = 22,
1142   BuiltinOptions_GatherOptions = 23,
1143   BuiltinOptions_BatchToSpaceNDOptions = 24,
1144   BuiltinOptions_SpaceToBatchNDOptions = 25,
1145   BuiltinOptions_TransposeOptions = 26,
1146   BuiltinOptions_ReducerOptions = 27,
1147   BuiltinOptions_SubOptions = 28,
1148   BuiltinOptions_DivOptions = 29,
1149   BuiltinOptions_SqueezeOptions = 30,
1150   BuiltinOptions_SequenceRNNOptions = 31,
1151   BuiltinOptions_StridedSliceOptions = 32,
1152   BuiltinOptions_ExpOptions = 33,
1153   BuiltinOptions_TopKV2Options = 34,
1154   BuiltinOptions_SplitOptions = 35,
1155   BuiltinOptions_LogSoftmaxOptions = 36,
1156   BuiltinOptions_CastOptions = 37,
1157   BuiltinOptions_DequantizeOptions = 38,
1158   BuiltinOptions_MaximumMinimumOptions = 39,
1159   BuiltinOptions_ArgMaxOptions = 40,
1160   BuiltinOptions_LessOptions = 41,
1161   BuiltinOptions_NegOptions = 42,
1162   BuiltinOptions_PadV2Options = 43,
1163   BuiltinOptions_GreaterOptions = 44,
1164   BuiltinOptions_GreaterEqualOptions = 45,
1165   BuiltinOptions_LessEqualOptions = 46,
1166   BuiltinOptions_SelectOptions = 47,
1167   BuiltinOptions_SliceOptions = 48,
1168   BuiltinOptions_TransposeConvOptions = 49,
1169   BuiltinOptions_SparseToDenseOptions = 50,
1170   BuiltinOptions_TileOptions = 51,
1171   BuiltinOptions_ExpandDimsOptions = 52,
1172   BuiltinOptions_EqualOptions = 53,
1173   BuiltinOptions_NotEqualOptions = 54,
1174   BuiltinOptions_ShapeOptions = 55,
1175   BuiltinOptions_PowOptions = 56,
1176   BuiltinOptions_ArgMinOptions = 57,
1177   BuiltinOptions_FakeQuantOptions = 58,
1178   BuiltinOptions_PackOptions = 59,
1179   BuiltinOptions_LogicalOrOptions = 60,
1180   BuiltinOptions_OneHotOptions = 61,
1181   BuiltinOptions_LogicalAndOptions = 62,
1182   BuiltinOptions_LogicalNotOptions = 63,
1183   BuiltinOptions_UnpackOptions = 64,
1184   BuiltinOptions_FloorDivOptions = 65,
1185   BuiltinOptions_SquareOptions = 66,
1186   BuiltinOptions_ZerosLikeOptions = 67,
1187   BuiltinOptions_FillOptions = 68,
1188   BuiltinOptions_BidirectionalSequenceLSTMOptions = 69,
1189   BuiltinOptions_BidirectionalSequenceRNNOptions = 70,
1190   BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71,
1191   BuiltinOptions_FloorModOptions = 72,
1192   BuiltinOptions_RangeOptions = 73,
1193   BuiltinOptions_ResizeNearestNeighborOptions = 74,
1194   BuiltinOptions_LeakyReluOptions = 75,
1195   BuiltinOptions_SquaredDifferenceOptions = 76,
1196   BuiltinOptions_MirrorPadOptions = 77,
1197   BuiltinOptions_AbsOptions = 78,
1198   BuiltinOptions_SplitVOptions = 79,
1199   BuiltinOptions_UniqueOptions = 80,
1200   BuiltinOptions_ReverseV2Options = 81,
1201   BuiltinOptions_AddNOptions = 82,
1202   BuiltinOptions_GatherNdOptions = 83,
1203   BuiltinOptions_CosOptions = 84,
1204   BuiltinOptions_WhereOptions = 85,
1205   BuiltinOptions_RankOptions = 86,
1206   BuiltinOptions_ReverseSequenceOptions = 87,
1207   BuiltinOptions_MatrixDiagOptions = 88,
1208   BuiltinOptions_QuantizeOptions = 89,
1209   BuiltinOptions_MatrixSetDiagOptions = 90,
1210   BuiltinOptions_HardSwishOptions = 91,
1211   BuiltinOptions_IfOptions = 92,
1212   BuiltinOptions_WhileOptions = 93,
1213   BuiltinOptions_DepthToSpaceOptions = 94,
1214   BuiltinOptions_NonMaxSuppressionV4Options = 95,
1215   BuiltinOptions_NonMaxSuppressionV5Options = 96,
1216   BuiltinOptions_ScatterNdOptions = 97,
1217   BuiltinOptions_SelectV2Options = 98,
1218   BuiltinOptions_DensifyOptions = 99,
1219   BuiltinOptions_SegmentSumOptions = 100,
1220   BuiltinOptions_BatchMatMulOptions = 101,
1221   BuiltinOptions_CumsumOptions = 102,
1222   BuiltinOptions_CallOnceOptions = 103,
1223   BuiltinOptions_BroadcastToOptions = 104,
1224   BuiltinOptions_Rfft2dOptions = 105,
1225   BuiltinOptions_Conv3DOptions = 106,
1226   BuiltinOptions_HashtableOptions = 107,
1227   BuiltinOptions_HashtableFindOptions = 108,
1228   BuiltinOptions_HashtableImportOptions = 109,
1229   BuiltinOptions_HashtableSizeOptions = 110,
1230   BuiltinOptions_VarHandleOptions = 111,
1231   BuiltinOptions_ReadVariableOptions = 112,
1232   BuiltinOptions_AssignVariableOptions = 113,
1233   BuiltinOptions_RandomOptions = 114,
1234   BuiltinOptions_BucketizeOptions = 115,
1235   BuiltinOptions_GeluOptions = 116,
1236   BuiltinOptions_DynamicUpdateSliceOptions = 117,
1237   BuiltinOptions_UnsortedSegmentProdOptions = 118,
1238   BuiltinOptions_UnsortedSegmentMaxOptions = 119,
1239   BuiltinOptions_UnsortedSegmentSumOptions = 120,
1240   BuiltinOptions_ATan2Options = 121,
1241   BuiltinOptions_MIN = BuiltinOptions_NONE,
1242   BuiltinOptions_MAX = BuiltinOptions_ATan2Options
1243 };
1244
1245 inline const BuiltinOptions (&EnumValuesBuiltinOptions())[122]
1246 {
1247   static const BuiltinOptions values[] = {BuiltinOptions_NONE,
1248                                           BuiltinOptions_Conv2DOptions,
1249                                           BuiltinOptions_DepthwiseConv2DOptions,
1250                                           BuiltinOptions_ConcatEmbeddingsOptions,
1251                                           BuiltinOptions_LSHProjectionOptions,
1252                                           BuiltinOptions_Pool2DOptions,
1253                                           BuiltinOptions_SVDFOptions,
1254                                           BuiltinOptions_RNNOptions,
1255                                           BuiltinOptions_FullyConnectedOptions,
1256                                           BuiltinOptions_SoftmaxOptions,
1257                                           BuiltinOptions_ConcatenationOptions,
1258                                           BuiltinOptions_AddOptions,
1259                                           BuiltinOptions_L2NormOptions,
1260                                           BuiltinOptions_LocalResponseNormalizationOptions,
1261                                           BuiltinOptions_LSTMOptions,
1262                                           BuiltinOptions_ResizeBilinearOptions,
1263                                           BuiltinOptions_CallOptions,
1264                                           BuiltinOptions_ReshapeOptions,
1265                                           BuiltinOptions_SkipGramOptions,
1266                                           BuiltinOptions_SpaceToDepthOptions,
1267                                           BuiltinOptions_EmbeddingLookupSparseOptions,
1268                                           BuiltinOptions_MulOptions,
1269                                           BuiltinOptions_PadOptions,
1270                                           BuiltinOptions_GatherOptions,
1271                                           BuiltinOptions_BatchToSpaceNDOptions,
1272                                           BuiltinOptions_SpaceToBatchNDOptions,
1273                                           BuiltinOptions_TransposeOptions,
1274                                           BuiltinOptions_ReducerOptions,
1275                                           BuiltinOptions_SubOptions,
1276                                           BuiltinOptions_DivOptions,
1277                                           BuiltinOptions_SqueezeOptions,
1278                                           BuiltinOptions_SequenceRNNOptions,
1279                                           BuiltinOptions_StridedSliceOptions,
1280                                           BuiltinOptions_ExpOptions,
1281                                           BuiltinOptions_TopKV2Options,
1282                                           BuiltinOptions_SplitOptions,
1283                                           BuiltinOptions_LogSoftmaxOptions,
1284                                           BuiltinOptions_CastOptions,
1285                                           BuiltinOptions_DequantizeOptions,
1286                                           BuiltinOptions_MaximumMinimumOptions,
1287                                           BuiltinOptions_ArgMaxOptions,
1288                                           BuiltinOptions_LessOptions,
1289                                           BuiltinOptions_NegOptions,
1290                                           BuiltinOptions_PadV2Options,
1291                                           BuiltinOptions_GreaterOptions,
1292                                           BuiltinOptions_GreaterEqualOptions,
1293                                           BuiltinOptions_LessEqualOptions,
1294                                           BuiltinOptions_SelectOptions,
1295                                           BuiltinOptions_SliceOptions,
1296                                           BuiltinOptions_TransposeConvOptions,
1297                                           BuiltinOptions_SparseToDenseOptions,
1298                                           BuiltinOptions_TileOptions,
1299                                           BuiltinOptions_ExpandDimsOptions,
1300                                           BuiltinOptions_EqualOptions,
1301                                           BuiltinOptions_NotEqualOptions,
1302                                           BuiltinOptions_ShapeOptions,
1303                                           BuiltinOptions_PowOptions,
1304                                           BuiltinOptions_ArgMinOptions,
1305                                           BuiltinOptions_FakeQuantOptions,
1306                                           BuiltinOptions_PackOptions,
1307                                           BuiltinOptions_LogicalOrOptions,
1308                                           BuiltinOptions_OneHotOptions,
1309                                           BuiltinOptions_LogicalAndOptions,
1310                                           BuiltinOptions_LogicalNotOptions,
1311                                           BuiltinOptions_UnpackOptions,
1312                                           BuiltinOptions_FloorDivOptions,
1313                                           BuiltinOptions_SquareOptions,
1314                                           BuiltinOptions_ZerosLikeOptions,
1315                                           BuiltinOptions_FillOptions,
1316                                           BuiltinOptions_BidirectionalSequenceLSTMOptions,
1317                                           BuiltinOptions_BidirectionalSequenceRNNOptions,
1318                                           BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1319                                           BuiltinOptions_FloorModOptions,
1320                                           BuiltinOptions_RangeOptions,
1321                                           BuiltinOptions_ResizeNearestNeighborOptions,
1322                                           BuiltinOptions_LeakyReluOptions,
1323                                           BuiltinOptions_SquaredDifferenceOptions,
1324                                           BuiltinOptions_MirrorPadOptions,
1325                                           BuiltinOptions_AbsOptions,
1326                                           BuiltinOptions_SplitVOptions,
1327                                           BuiltinOptions_UniqueOptions,
1328                                           BuiltinOptions_ReverseV2Options,
1329                                           BuiltinOptions_AddNOptions,
1330                                           BuiltinOptions_GatherNdOptions,
1331                                           BuiltinOptions_CosOptions,
1332                                           BuiltinOptions_WhereOptions,
1333                                           BuiltinOptions_RankOptions,
1334                                           BuiltinOptions_ReverseSequenceOptions,
1335                                           BuiltinOptions_MatrixDiagOptions,
1336                                           BuiltinOptions_QuantizeOptions,
1337                                           BuiltinOptions_MatrixSetDiagOptions,
1338                                           BuiltinOptions_HardSwishOptions,
1339                                           BuiltinOptions_IfOptions,
1340                                           BuiltinOptions_WhileOptions,
1341                                           BuiltinOptions_DepthToSpaceOptions,
1342                                           BuiltinOptions_NonMaxSuppressionV4Options,
1343                                           BuiltinOptions_NonMaxSuppressionV5Options,
1344                                           BuiltinOptions_ScatterNdOptions,
1345                                           BuiltinOptions_SelectV2Options,
1346                                           BuiltinOptions_DensifyOptions,
1347                                           BuiltinOptions_SegmentSumOptions,
1348                                           BuiltinOptions_BatchMatMulOptions,
1349                                           BuiltinOptions_CumsumOptions,
1350                                           BuiltinOptions_CallOnceOptions,
1351                                           BuiltinOptions_BroadcastToOptions,
1352                                           BuiltinOptions_Rfft2dOptions,
1353                                           BuiltinOptions_Conv3DOptions,
1354                                           BuiltinOptions_HashtableOptions,
1355                                           BuiltinOptions_HashtableFindOptions,
1356                                           BuiltinOptions_HashtableImportOptions,
1357                                           BuiltinOptions_HashtableSizeOptions,
1358                                           BuiltinOptions_VarHandleOptions,
1359                                           BuiltinOptions_ReadVariableOptions,
1360                                           BuiltinOptions_AssignVariableOptions,
1361                                           BuiltinOptions_RandomOptions,
1362                                           BuiltinOptions_BucketizeOptions,
1363                                           BuiltinOptions_GeluOptions,
1364                                           BuiltinOptions_DynamicUpdateSliceOptions,
1365                                           BuiltinOptions_UnsortedSegmentProdOptions,
1366                                           BuiltinOptions_UnsortedSegmentMaxOptions,
1367                                           BuiltinOptions_UnsortedSegmentSumOptions,
1368                                           BuiltinOptions_ATan2Options};
1369   return values;
1370 }
1371
1372 inline const char *const *EnumNamesBuiltinOptions()
1373 {
1374   static const char *const names[123] = {"NONE",
1375                                          "Conv2DOptions",
1376                                          "DepthwiseConv2DOptions",
1377                                          "ConcatEmbeddingsOptions",
1378                                          "LSHProjectionOptions",
1379                                          "Pool2DOptions",
1380                                          "SVDFOptions",
1381                                          "RNNOptions",
1382                                          "FullyConnectedOptions",
1383                                          "SoftmaxOptions",
1384                                          "ConcatenationOptions",
1385                                          "AddOptions",
1386                                          "L2NormOptions",
1387                                          "LocalResponseNormalizationOptions",
1388                                          "LSTMOptions",
1389                                          "ResizeBilinearOptions",
1390                                          "CallOptions",
1391                                          "ReshapeOptions",
1392                                          "SkipGramOptions",
1393                                          "SpaceToDepthOptions",
1394                                          "EmbeddingLookupSparseOptions",
1395                                          "MulOptions",
1396                                          "PadOptions",
1397                                          "GatherOptions",
1398                                          "BatchToSpaceNDOptions",
1399                                          "SpaceToBatchNDOptions",
1400                                          "TransposeOptions",
1401                                          "ReducerOptions",
1402                                          "SubOptions",
1403                                          "DivOptions",
1404                                          "SqueezeOptions",
1405                                          "SequenceRNNOptions",
1406                                          "StridedSliceOptions",
1407                                          "ExpOptions",
1408                                          "TopKV2Options",
1409                                          "SplitOptions",
1410                                          "LogSoftmaxOptions",
1411                                          "CastOptions",
1412                                          "DequantizeOptions",
1413                                          "MaximumMinimumOptions",
1414                                          "ArgMaxOptions",
1415                                          "LessOptions",
1416                                          "NegOptions",
1417                                          "PadV2Options",
1418                                          "GreaterOptions",
1419                                          "GreaterEqualOptions",
1420                                          "LessEqualOptions",
1421                                          "SelectOptions",
1422                                          "SliceOptions",
1423                                          "TransposeConvOptions",
1424                                          "SparseToDenseOptions",
1425                                          "TileOptions",
1426                                          "ExpandDimsOptions",
1427                                          "EqualOptions",
1428                                          "NotEqualOptions",
1429                                          "ShapeOptions",
1430                                          "PowOptions",
1431                                          "ArgMinOptions",
1432                                          "FakeQuantOptions",
1433                                          "PackOptions",
1434                                          "LogicalOrOptions",
1435                                          "OneHotOptions",
1436                                          "LogicalAndOptions",
1437                                          "LogicalNotOptions",
1438                                          "UnpackOptions",
1439                                          "FloorDivOptions",
1440                                          "SquareOptions",
1441                                          "ZerosLikeOptions",
1442                                          "FillOptions",
1443                                          "BidirectionalSequenceLSTMOptions",
1444                                          "BidirectionalSequenceRNNOptions",
1445                                          "UnidirectionalSequenceLSTMOptions",
1446                                          "FloorModOptions",
1447                                          "RangeOptions",
1448                                          "ResizeNearestNeighborOptions",
1449                                          "LeakyReluOptions",
1450                                          "SquaredDifferenceOptions",
1451                                          "MirrorPadOptions",
1452                                          "AbsOptions",
1453                                          "SplitVOptions",
1454                                          "UniqueOptions",
1455                                          "ReverseV2Options",
1456                                          "AddNOptions",
1457                                          "GatherNdOptions",
1458                                          "CosOptions",
1459                                          "WhereOptions",
1460                                          "RankOptions",
1461                                          "ReverseSequenceOptions",
1462                                          "MatrixDiagOptions",
1463                                          "QuantizeOptions",
1464                                          "MatrixSetDiagOptions",
1465                                          "HardSwishOptions",
1466                                          "IfOptions",
1467                                          "WhileOptions",
1468                                          "DepthToSpaceOptions",
1469                                          "NonMaxSuppressionV4Options",
1470                                          "NonMaxSuppressionV5Options",
1471                                          "ScatterNdOptions",
1472                                          "SelectV2Options",
1473                                          "DensifyOptions",
1474                                          "SegmentSumOptions",
1475                                          "BatchMatMulOptions",
1476                                          "CumsumOptions",
1477                                          "CallOnceOptions",
1478                                          "BroadcastToOptions",
1479                                          "Rfft2dOptions",
1480                                          "Conv3DOptions",
1481                                          "HashtableOptions",
1482                                          "HashtableFindOptions",
1483                                          "HashtableImportOptions",
1484                                          "HashtableSizeOptions",
1485                                          "VarHandleOptions",
1486                                          "ReadVariableOptions",
1487                                          "AssignVariableOptions",
1488                                          "RandomOptions",
1489                                          "BucketizeOptions",
1490                                          "GeluOptions",
1491                                          "DynamicUpdateSliceOptions",
1492                                          "UnsortedSegmentProdOptions",
1493                                          "UnsortedSegmentMaxOptions",
1494                                          "UnsortedSegmentSumOptions",
1495                                          "ATan2Options",
1496                                          nullptr};
1497   return names;
1498 }
1499
1500 inline const char *EnumNameBuiltinOptions(BuiltinOptions e)
1501 {
1502   if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_ATan2Options))
1503     return "";
1504   const size_t index = static_cast<size_t>(e);
1505   return EnumNamesBuiltinOptions()[index];
1506 }
1507
1508 template <typename T> struct BuiltinOptionsTraits
1509 {
1510   static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1511 };
1512
1513 template <> struct BuiltinOptionsTraits<onert_tflite::Conv2DOptions>
1514 {
1515   static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1516 };
1517
1518 template <> struct BuiltinOptionsTraits<onert_tflite::DepthwiseConv2DOptions>
1519 {
1520   static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1521 };
1522
1523 template <> struct BuiltinOptionsTraits<onert_tflite::ConcatEmbeddingsOptions>
1524 {
1525   static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1526 };
1527
1528 template <> struct BuiltinOptionsTraits<onert_tflite::LSHProjectionOptions>
1529 {
1530   static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1531 };
1532
1533 template <> struct BuiltinOptionsTraits<onert_tflite::Pool2DOptions>
1534 {
1535   static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1536 };
1537
1538 template <> struct BuiltinOptionsTraits<onert_tflite::SVDFOptions>
1539 {
1540   static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1541 };
1542
1543 template <> struct BuiltinOptionsTraits<onert_tflite::RNNOptions>
1544 {
1545   static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1546 };
1547
1548 template <> struct BuiltinOptionsTraits<onert_tflite::FullyConnectedOptions>
1549 {
1550   static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1551 };
1552
1553 template <> struct BuiltinOptionsTraits<onert_tflite::SoftmaxOptions>
1554 {
1555   static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1556 };
1557
1558 template <> struct BuiltinOptionsTraits<onert_tflite::ConcatenationOptions>
1559 {
1560   static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1561 };
1562
1563 template <> struct BuiltinOptionsTraits<onert_tflite::AddOptions>
1564 {
1565   static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1566 };
1567
1568 template <> struct BuiltinOptionsTraits<onert_tflite::L2NormOptions>
1569 {
1570   static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1571 };
1572
1573 template <> struct BuiltinOptionsTraits<onert_tflite::LocalResponseNormalizationOptions>
1574 {
1575   static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1576 };
1577
1578 template <> struct BuiltinOptionsTraits<onert_tflite::LSTMOptions>
1579 {
1580   static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1581 };
1582
1583 template <> struct BuiltinOptionsTraits<onert_tflite::ResizeBilinearOptions>
1584 {
1585   static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1586 };
1587
1588 template <> struct BuiltinOptionsTraits<onert_tflite::CallOptions>
1589 {
1590   static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1591 };
1592
1593 template <> struct BuiltinOptionsTraits<onert_tflite::ReshapeOptions>
1594 {
1595   static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1596 };
1597
1598 template <> struct BuiltinOptionsTraits<onert_tflite::SkipGramOptions>
1599 {
1600   static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1601 };
1602
1603 template <> struct BuiltinOptionsTraits<onert_tflite::SpaceToDepthOptions>
1604 {
1605   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1606 };
1607
1608 template <> struct BuiltinOptionsTraits<onert_tflite::EmbeddingLookupSparseOptions>
1609 {
1610   static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1611 };
1612
1613 template <> struct BuiltinOptionsTraits<onert_tflite::MulOptions>
1614 {
1615   static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1616 };
1617
1618 template <> struct BuiltinOptionsTraits<onert_tflite::PadOptions>
1619 {
1620   static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1621 };
1622
1623 template <> struct BuiltinOptionsTraits<onert_tflite::GatherOptions>
1624 {
1625   static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1626 };
1627
1628 template <> struct BuiltinOptionsTraits<onert_tflite::BatchToSpaceNDOptions>
1629 {
1630   static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
1631 };
1632
1633 template <> struct BuiltinOptionsTraits<onert_tflite::SpaceToBatchNDOptions>
1634 {
1635   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
1636 };
1637
1638 template <> struct BuiltinOptionsTraits<onert_tflite::TransposeOptions>
1639 {
1640   static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
1641 };
1642
1643 template <> struct BuiltinOptionsTraits<onert_tflite::ReducerOptions>
1644 {
1645   static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
1646 };
1647
1648 template <> struct BuiltinOptionsTraits<onert_tflite::SubOptions>
1649 {
1650   static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
1651 };
1652
1653 template <> struct BuiltinOptionsTraits<onert_tflite::DivOptions>
1654 {
1655   static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
1656 };
1657
1658 template <> struct BuiltinOptionsTraits<onert_tflite::SqueezeOptions>
1659 {
1660   static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
1661 };
1662
1663 template <> struct BuiltinOptionsTraits<onert_tflite::SequenceRNNOptions>
1664 {
1665   static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
1666 };
1667
1668 template <> struct BuiltinOptionsTraits<onert_tflite::StridedSliceOptions>
1669 {
1670   static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
1671 };
1672
1673 template <> struct BuiltinOptionsTraits<onert_tflite::ExpOptions>
1674 {
1675   static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
1676 };
1677
1678 template <> struct BuiltinOptionsTraits<onert_tflite::TopKV2Options>
1679 {
1680   static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
1681 };
1682
1683 template <> struct BuiltinOptionsTraits<onert_tflite::SplitOptions>
1684 {
1685   static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
1686 };
1687
1688 template <> struct BuiltinOptionsTraits<onert_tflite::LogSoftmaxOptions>
1689 {
1690   static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
1691 };
1692
1693 template <> struct BuiltinOptionsTraits<onert_tflite::CastOptions>
1694 {
1695   static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
1696 };
1697
1698 template <> struct BuiltinOptionsTraits<onert_tflite::DequantizeOptions>
1699 {
1700   static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
1701 };
1702
1703 template <> struct BuiltinOptionsTraits<onert_tflite::MaximumMinimumOptions>
1704 {
1705   static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
1706 };
1707
1708 template <> struct BuiltinOptionsTraits<onert_tflite::ArgMaxOptions>
1709 {
1710   static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
1711 };
1712
1713 template <> struct BuiltinOptionsTraits<onert_tflite::LessOptions>
1714 {
1715   static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
1716 };
1717
1718 template <> struct BuiltinOptionsTraits<onert_tflite::NegOptions>
1719 {
1720   static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
1721 };
1722
1723 template <> struct BuiltinOptionsTraits<onert_tflite::PadV2Options>
1724 {
1725   static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
1726 };
1727
1728 template <> struct BuiltinOptionsTraits<onert_tflite::GreaterOptions>
1729 {
1730   static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
1731 };
1732
1733 template <> struct BuiltinOptionsTraits<onert_tflite::GreaterEqualOptions>
1734 {
1735   static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
1736 };
1737
1738 template <> struct BuiltinOptionsTraits<onert_tflite::LessEqualOptions>
1739 {
1740   static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
1741 };
1742
1743 template <> struct BuiltinOptionsTraits<onert_tflite::SelectOptions>
1744 {
1745   static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
1746 };
1747
1748 template <> struct BuiltinOptionsTraits<onert_tflite::SliceOptions>
1749 {
1750   static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
1751 };
1752
1753 template <> struct BuiltinOptionsTraits<onert_tflite::TransposeConvOptions>
1754 {
1755   static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
1756 };
1757
1758 template <> struct BuiltinOptionsTraits<onert_tflite::SparseToDenseOptions>
1759 {
1760   static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
1761 };
1762
1763 template <> struct BuiltinOptionsTraits<onert_tflite::TileOptions>
1764 {
1765   static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
1766 };
1767
1768 template <> struct BuiltinOptionsTraits<onert_tflite::ExpandDimsOptions>
1769 {
1770   static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
1771 };
1772
1773 template <> struct BuiltinOptionsTraits<onert_tflite::EqualOptions>
1774 {
1775   static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
1776 };
1777
1778 template <> struct BuiltinOptionsTraits<onert_tflite::NotEqualOptions>
1779 {
1780   static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
1781 };
1782
1783 template <> struct BuiltinOptionsTraits<onert_tflite::ShapeOptions>
1784 {
1785   static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
1786 };
1787
1788 template <> struct BuiltinOptionsTraits<onert_tflite::PowOptions>
1789 {
1790   static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
1791 };
1792
1793 template <> struct BuiltinOptionsTraits<onert_tflite::ArgMinOptions>
1794 {
1795   static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
1796 };
1797
1798 template <> struct BuiltinOptionsTraits<onert_tflite::FakeQuantOptions>
1799 {
1800   static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
1801 };
1802
1803 template <> struct BuiltinOptionsTraits<onert_tflite::PackOptions>
1804 {
1805   static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
1806 };
1807
1808 template <> struct BuiltinOptionsTraits<onert_tflite::LogicalOrOptions>
1809 {
1810   static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
1811 };
1812
1813 template <> struct BuiltinOptionsTraits<onert_tflite::OneHotOptions>
1814 {
1815   static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
1816 };
1817
1818 template <> struct BuiltinOptionsTraits<onert_tflite::LogicalAndOptions>
1819 {
1820   static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
1821 };
1822
1823 template <> struct BuiltinOptionsTraits<onert_tflite::LogicalNotOptions>
1824 {
1825   static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
1826 };
1827
1828 template <> struct BuiltinOptionsTraits<onert_tflite::UnpackOptions>
1829 {
1830   static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
1831 };
1832
1833 template <> struct BuiltinOptionsTraits<onert_tflite::FloorDivOptions>
1834 {
1835   static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
1836 };
1837
1838 template <> struct BuiltinOptionsTraits<onert_tflite::SquareOptions>
1839 {
1840   static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
1841 };
1842
1843 template <> struct BuiltinOptionsTraits<onert_tflite::ZerosLikeOptions>
1844 {
1845   static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
1846 };
1847
1848 template <> struct BuiltinOptionsTraits<onert_tflite::FillOptions>
1849 {
1850   static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
1851 };
1852
1853 template <> struct BuiltinOptionsTraits<onert_tflite::BidirectionalSequenceLSTMOptions>
1854 {
1855   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
1856 };
1857
1858 template <> struct BuiltinOptionsTraits<onert_tflite::BidirectionalSequenceRNNOptions>
1859 {
1860   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
1861 };
1862
1863 template <> struct BuiltinOptionsTraits<onert_tflite::UnidirectionalSequenceLSTMOptions>
1864 {
1865   static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
1866 };
1867
1868 template <> struct BuiltinOptionsTraits<onert_tflite::FloorModOptions>
1869 {
1870   static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
1871 };
1872
1873 template <> struct BuiltinOptionsTraits<onert_tflite::RangeOptions>
1874 {
1875   static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
1876 };
1877
1878 template <> struct BuiltinOptionsTraits<onert_tflite::ResizeNearestNeighborOptions>
1879 {
1880   static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
1881 };
1882
1883 template <> struct BuiltinOptionsTraits<onert_tflite::LeakyReluOptions>
1884 {
1885   static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
1886 };
1887
1888 template <> struct BuiltinOptionsTraits<onert_tflite::SquaredDifferenceOptions>
1889 {
1890   static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
1891 };
1892
1893 template <> struct BuiltinOptionsTraits<onert_tflite::MirrorPadOptions>
1894 {
1895   static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
1896 };
1897
1898 template <> struct BuiltinOptionsTraits<onert_tflite::AbsOptions>
1899 {
1900   static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
1901 };
1902
1903 template <> struct BuiltinOptionsTraits<onert_tflite::SplitVOptions>
1904 {
1905   static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
1906 };
1907
1908 template <> struct BuiltinOptionsTraits<onert_tflite::UniqueOptions>
1909 {
1910   static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
1911 };
1912
1913 template <> struct BuiltinOptionsTraits<onert_tflite::ReverseV2Options>
1914 {
1915   static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
1916 };
1917
1918 template <> struct BuiltinOptionsTraits<onert_tflite::AddNOptions>
1919 {
1920   static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
1921 };
1922
1923 template <> struct BuiltinOptionsTraits<onert_tflite::GatherNdOptions>
1924 {
1925   static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
1926 };
1927
1928 template <> struct BuiltinOptionsTraits<onert_tflite::CosOptions>
1929 {
1930   static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
1931 };
1932
1933 template <> struct BuiltinOptionsTraits<onert_tflite::WhereOptions>
1934 {
1935   static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
1936 };
1937
1938 template <> struct BuiltinOptionsTraits<onert_tflite::RankOptions>
1939 {
1940   static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
1941 };
1942
1943 template <> struct BuiltinOptionsTraits<onert_tflite::ReverseSequenceOptions>
1944 {
1945   static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
1946 };
1947
1948 template <> struct BuiltinOptionsTraits<onert_tflite::MatrixDiagOptions>
1949 {
1950   static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
1951 };
1952
1953 template <> struct BuiltinOptionsTraits<onert_tflite::QuantizeOptions>
1954 {
1955   static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
1956 };
1957
1958 template <> struct BuiltinOptionsTraits<onert_tflite::MatrixSetDiagOptions>
1959 {
1960   static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
1961 };
1962
1963 template <> struct BuiltinOptionsTraits<onert_tflite::HardSwishOptions>
1964 {
1965   static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
1966 };
1967
1968 template <> struct BuiltinOptionsTraits<onert_tflite::IfOptions>
1969 {
1970   static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
1971 };
1972
1973 template <> struct BuiltinOptionsTraits<onert_tflite::WhileOptions>
1974 {
1975   static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
1976 };
1977
1978 template <> struct BuiltinOptionsTraits<onert_tflite::DepthToSpaceOptions>
1979 {
1980   static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
1981 };
1982
1983 template <> struct BuiltinOptionsTraits<onert_tflite::NonMaxSuppressionV4Options>
1984 {
1985   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
1986 };
1987
1988 template <> struct BuiltinOptionsTraits<onert_tflite::NonMaxSuppressionV5Options>
1989 {
1990   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
1991 };
1992
1993 template <> struct BuiltinOptionsTraits<onert_tflite::ScatterNdOptions>
1994 {
1995   static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
1996 };
1997
1998 template <> struct BuiltinOptionsTraits<onert_tflite::SelectV2Options>
1999 {
2000   static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
2001 };
2002
2003 template <> struct BuiltinOptionsTraits<onert_tflite::DensifyOptions>
2004 {
2005   static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
2006 };
2007
2008 template <> struct BuiltinOptionsTraits<onert_tflite::SegmentSumOptions>
2009 {
2010   static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
2011 };
2012
2013 template <> struct BuiltinOptionsTraits<onert_tflite::BatchMatMulOptions>
2014 {
2015   static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
2016 };
2017
2018 template <> struct BuiltinOptionsTraits<onert_tflite::CumsumOptions>
2019 {
2020   static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
2021 };
2022
2023 template <> struct BuiltinOptionsTraits<onert_tflite::CallOnceOptions>
2024 {
2025   static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
2026 };
2027
2028 template <> struct BuiltinOptionsTraits<onert_tflite::BroadcastToOptions>
2029 {
2030   static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
2031 };
2032
2033 template <> struct BuiltinOptionsTraits<onert_tflite::Rfft2dOptions>
2034 {
2035   static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
2036 };
2037
2038 template <> struct BuiltinOptionsTraits<onert_tflite::Conv3DOptions>
2039 {
2040   static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
2041 };
2042
2043 template <> struct BuiltinOptionsTraits<onert_tflite::HashtableOptions>
2044 {
2045   static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
2046 };
2047
2048 template <> struct BuiltinOptionsTraits<onert_tflite::HashtableFindOptions>
2049 {
2050   static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
2051 };
2052
2053 template <> struct BuiltinOptionsTraits<onert_tflite::HashtableImportOptions>
2054 {
2055   static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
2056 };
2057
2058 template <> struct BuiltinOptionsTraits<onert_tflite::HashtableSizeOptions>
2059 {
2060   static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
2061 };
2062
2063 template <> struct BuiltinOptionsTraits<onert_tflite::VarHandleOptions>
2064 {
2065   static const BuiltinOptions enum_value = BuiltinOptions_VarHandleOptions;
2066 };
2067
2068 template <> struct BuiltinOptionsTraits<onert_tflite::ReadVariableOptions>
2069 {
2070   static const BuiltinOptions enum_value = BuiltinOptions_ReadVariableOptions;
2071 };
2072
2073 template <> struct BuiltinOptionsTraits<onert_tflite::AssignVariableOptions>
2074 {
2075   static const BuiltinOptions enum_value = BuiltinOptions_AssignVariableOptions;
2076 };
2077
2078 template <> struct BuiltinOptionsTraits<onert_tflite::RandomOptions>
2079 {
2080   static const BuiltinOptions enum_value = BuiltinOptions_RandomOptions;
2081 };
2082
2083 template <> struct BuiltinOptionsTraits<onert_tflite::BucketizeOptions>
2084 {
2085   static const BuiltinOptions enum_value = BuiltinOptions_BucketizeOptions;
2086 };
2087
2088 template <> struct BuiltinOptionsTraits<onert_tflite::GeluOptions>
2089 {
2090   static const BuiltinOptions enum_value = BuiltinOptions_GeluOptions;
2091 };
2092
2093 template <> struct BuiltinOptionsTraits<onert_tflite::DynamicUpdateSliceOptions>
2094 {
2095   static const BuiltinOptions enum_value = BuiltinOptions_DynamicUpdateSliceOptions;
2096 };
2097
2098 template <> struct BuiltinOptionsTraits<onert_tflite::UnsortedSegmentProdOptions>
2099 {
2100   static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentProdOptions;
2101 };
2102
2103 template <> struct BuiltinOptionsTraits<onert_tflite::UnsortedSegmentMaxOptions>
2104 {
2105   static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentMaxOptions;
2106 };
2107
2108 template <> struct BuiltinOptionsTraits<onert_tflite::UnsortedSegmentSumOptions>
2109 {
2110   static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentSumOptions;
2111 };
2112
2113 template <> struct BuiltinOptionsTraits<onert_tflite::ATan2Options>
2114 {
2115   static const BuiltinOptions enum_value = BuiltinOptions_ATan2Options;
2116 };
2117
2118 bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
2119 bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
2120                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
2121                                 const flatbuffers::Vector<uint8_t> *types);
2122
2123 enum Padding : int8_t
2124 {
2125   Padding_SAME = 0,
2126   Padding_VALID = 1,
2127   Padding_MIN = Padding_SAME,
2128   Padding_MAX = Padding_VALID
2129 };
2130
2131 inline const Padding (&EnumValuesPadding())[2]
2132 {
2133   static const Padding values[] = {Padding_SAME, Padding_VALID};
2134   return values;
2135 }
2136
2137 inline const char *const *EnumNamesPadding()
2138 {
2139   static const char *const names[3] = {"SAME", "VALID", nullptr};
2140   return names;
2141 }
2142
2143 inline const char *EnumNamePadding(Padding e)
2144 {
2145   if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID))
2146     return "";
2147   const size_t index = static_cast<size_t>(e);
2148   return EnumNamesPadding()[index];
2149 }
2150
2151 enum ActivationFunctionType : int8_t
2152 {
2153   ActivationFunctionType_NONE = 0,
2154   ActivationFunctionType_RELU = 1,
2155   ActivationFunctionType_RELU_N1_TO_1 = 2,
2156   ActivationFunctionType_RELU6 = 3,
2157   ActivationFunctionType_TANH = 4,
2158   ActivationFunctionType_SIGN_BIT = 5,
2159   ActivationFunctionType_MIN = ActivationFunctionType_NONE,
2160   ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
2161 };
2162
2163 inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6]
2164 {
2165   static const ActivationFunctionType values[] = {
2166     ActivationFunctionType_NONE,  ActivationFunctionType_RELU, ActivationFunctionType_RELU_N1_TO_1,
2167     ActivationFunctionType_RELU6, ActivationFunctionType_TANH, ActivationFunctionType_SIGN_BIT};
2168   return values;
2169 }
2170
2171 inline const char *const *EnumNamesActivationFunctionType()
2172 {
2173   static const char *const names[7] = {"NONE", "RELU",     "RELU_N1_TO_1", "RELU6",
2174                                        "TANH", "SIGN_BIT", nullptr};
2175   return names;
2176 }
2177
2178 inline const char *EnumNameActivationFunctionType(ActivationFunctionType e)
2179 {
2180   if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT))
2181     return "";
2182   const size_t index = static_cast<size_t>(e);
2183   return EnumNamesActivationFunctionType()[index];
2184 }
2185
2186 enum LSHProjectionType : int8_t
2187 {
2188   LSHProjectionType_UNKNOWN = 0,
2189   LSHProjectionType_SPARSE = 1,
2190   LSHProjectionType_DENSE = 2,
2191   LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
2192   LSHProjectionType_MAX = LSHProjectionType_DENSE
2193 };
2194
2195 inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3]
2196 {
2197   static const LSHProjectionType values[] = {LSHProjectionType_UNKNOWN, LSHProjectionType_SPARSE,
2198                                              LSHProjectionType_DENSE};
2199   return values;
2200 }
2201
2202 inline const char *const *EnumNamesLSHProjectionType()
2203 {
2204   static const char *const names[4] = {"UNKNOWN", "SPARSE", "DENSE", nullptr};
2205   return names;
2206 }
2207
2208 inline const char *EnumNameLSHProjectionType(LSHProjectionType e)
2209 {
2210   if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE))
2211     return "";
2212   const size_t index = static_cast<size_t>(e);
2213   return EnumNamesLSHProjectionType()[index];
2214 }
2215
2216 enum FullyConnectedOptionsWeightsFormat : int8_t
2217 {
2218   FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
2219   FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
2220   FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
2221   FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
2222 };
2223
2224 inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2]
2225 {
2226   static const FullyConnectedOptionsWeightsFormat values[] = {
2227     FullyConnectedOptionsWeightsFormat_DEFAULT,
2228     FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8};
2229   return values;
2230 }
2231
2232 inline const char *const *EnumNamesFullyConnectedOptionsWeightsFormat()
2233 {
2234   static const char *const names[3] = {"DEFAULT", "SHUFFLED4x16INT8", nullptr};
2235   return names;
2236 }
2237
2238 inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e)
2239 {
2240   if (flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT,
2241                               FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8))
2242     return "";
2243   const size_t index = static_cast<size_t>(e);
2244   return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
2245 }
2246
2247 enum LSTMKernelType : int8_t
2248 {
2249   LSTMKernelType_FULL = 0,
2250   LSTMKernelType_BASIC = 1,
2251   LSTMKernelType_MIN = LSTMKernelType_FULL,
2252   LSTMKernelType_MAX = LSTMKernelType_BASIC
2253 };
2254
2255 inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2]
2256 {
2257   static const LSTMKernelType values[] = {LSTMKernelType_FULL, LSTMKernelType_BASIC};
2258   return values;
2259 }
2260
2261 inline const char *const *EnumNamesLSTMKernelType()
2262 {
2263   static const char *const names[3] = {"FULL", "BASIC", nullptr};
2264   return names;
2265 }
2266
2267 inline const char *EnumNameLSTMKernelType(LSTMKernelType e)
2268 {
2269   if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC))
2270     return "";
2271   const size_t index = static_cast<size_t>(e);
2272   return EnumNamesLSTMKernelType()[index];
2273 }
2274
2275 enum CombinerType : int8_t
2276 {
2277   CombinerType_SUM = 0,
2278   CombinerType_MEAN = 1,
2279   CombinerType_SQRTN = 2,
2280   CombinerType_MIN = CombinerType_SUM,
2281   CombinerType_MAX = CombinerType_SQRTN
2282 };
2283
2284 inline const CombinerType (&EnumValuesCombinerType())[3]
2285 {
2286   static const CombinerType values[] = {CombinerType_SUM, CombinerType_MEAN, CombinerType_SQRTN};
2287   return values;
2288 }
2289
2290 inline const char *const *EnumNamesCombinerType()
2291 {
2292   static const char *const names[4] = {"SUM", "MEAN", "SQRTN", nullptr};
2293   return names;
2294 }
2295
2296 inline const char *EnumNameCombinerType(CombinerType e)
2297 {
2298   if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN))
2299     return "";
2300   const size_t index = static_cast<size_t>(e);
2301   return EnumNamesCombinerType()[index];
2302 }
2303
2304 enum MirrorPadMode : int8_t
2305 {
2306   MirrorPadMode_REFLECT = 0,
2307   MirrorPadMode_SYMMETRIC = 1,
2308   MirrorPadMode_MIN = MirrorPadMode_REFLECT,
2309   MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
2310 };
2311
2312 inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2]
2313 {
2314   static const MirrorPadMode values[] = {MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC};
2315   return values;
2316 }
2317
2318 inline const char *const *EnumNamesMirrorPadMode()
2319 {
2320   static const char *const names[3] = {"REFLECT", "SYMMETRIC", nullptr};
2321   return names;
2322 }
2323
2324 inline const char *EnumNameMirrorPadMode(MirrorPadMode e)
2325 {
2326   if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC))
2327     return "";
2328   const size_t index = static_cast<size_t>(e);
2329   return EnumNamesMirrorPadMode()[index];
2330 }
2331
2332 enum CustomOptionsFormat : int8_t
2333 {
2334   CustomOptionsFormat_FLEXBUFFERS = 0,
2335   CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
2336   CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
2337 };
2338
2339 inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1]
2340 {
2341   static const CustomOptionsFormat values[] = {CustomOptionsFormat_FLEXBUFFERS};
2342   return values;
2343 }
2344
2345 inline const char *const *EnumNamesCustomOptionsFormat()
2346 {
2347   static const char *const names[2] = {"FLEXBUFFERS", nullptr};
2348   return names;
2349 }
2350
2351 inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e)
2352 {
2353   if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS))
2354     return "";
2355   const size_t index = static_cast<size_t>(e);
2356   return EnumNamesCustomOptionsFormat()[index];
2357 }
2358
2359 struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2360 {
2361   typedef CustomQuantizationBuilder Builder;
2362   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2363   {
2364     VT_CUSTOM = 4
2365   };
2366   const flatbuffers::Vector<uint8_t> *custom() const
2367   {
2368     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
2369   }
2370   bool Verify(flatbuffers::Verifier &verifier) const
2371   {
2372     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CUSTOM) &&
2373            verifier.VerifyVector(custom()) && verifier.EndTable();
2374   }
2375 };
2376
2377 struct CustomQuantizationBuilder
2378 {
2379   typedef CustomQuantization Table;
2380   flatbuffers::FlatBufferBuilder &fbb_;
2381   flatbuffers::uoffset_t start_;
2382   void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom)
2383   {
2384     fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
2385   }
2386   explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2387   {
2388     start_ = fbb_.StartTable();
2389   }
2390   flatbuffers::Offset<CustomQuantization> Finish()
2391   {
2392     const auto end = fbb_.EndTable(start_);
2393     auto o = flatbuffers::Offset<CustomQuantization>(end);
2394     return o;
2395   }
2396 };
2397
2398 inline flatbuffers::Offset<CustomQuantization>
2399 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb,
2400                          flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0)
2401 {
2402   CustomQuantizationBuilder builder_(_fbb);
2403   builder_.add_custom(custom);
2404   return builder_.Finish();
2405 }
2406
2407 inline flatbuffers::Offset<CustomQuantization>
2408 CreateCustomQuantizationDirect(flatbuffers::FlatBufferBuilder &_fbb,
2409                                const std::vector<uint8_t> *custom = nullptr)
2410 {
2411   if (custom)
2412   {
2413     _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16);
2414   }
2415   auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
2416   return onert_tflite::CreateCustomQuantization(_fbb, custom__);
2417 }
2418
2419 struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2420 {
2421   typedef QuantizationParametersBuilder Builder;
2422   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2423   {
2424     VT_MIN = 4,
2425     VT_MAX = 6,
2426     VT_SCALE = 8,
2427     VT_ZERO_POINT = 10,
2428     VT_DETAILS_TYPE = 12,
2429     VT_DETAILS = 14,
2430     VT_QUANTIZED_DIMENSION = 16
2431   };
2432   const flatbuffers::Vector<float> *min() const
2433   {
2434     return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
2435   }
2436   const flatbuffers::Vector<float> *max() const
2437   {
2438     return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
2439   }
2440   const flatbuffers::Vector<float> *scale() const
2441   {
2442     return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
2443   }
2444   const flatbuffers::Vector<int64_t> *zero_point() const
2445   {
2446     return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
2447   }
2448   onert_tflite::QuantizationDetails details_type() const
2449   {
2450     return static_cast<onert_tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
2451   }
2452   const void *details() const { return GetPointer<const void *>(VT_DETAILS); }
2453   template <typename T> const T *details_as() const;
2454   const onert_tflite::CustomQuantization *details_as_CustomQuantization() const
2455   {
2456     return details_type() == onert_tflite::QuantizationDetails_CustomQuantization
2457              ? static_cast<const onert_tflite::CustomQuantization *>(details())
2458              : nullptr;
2459   }
2460   int32_t quantized_dimension() const { return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0); }
2461   bool Verify(flatbuffers::Verifier &verifier) const
2462   {
2463     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) &&
2464            verifier.VerifyVector(min()) && VerifyOffset(verifier, VT_MAX) &&
2465            verifier.VerifyVector(max()) && VerifyOffset(verifier, VT_SCALE) &&
2466            verifier.VerifyVector(scale()) && VerifyOffset(verifier, VT_ZERO_POINT) &&
2467            verifier.VerifyVector(zero_point()) && VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
2468            VerifyOffset(verifier, VT_DETAILS) &&
2469            VerifyQuantizationDetails(verifier, details(), details_type()) &&
2470            VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) && verifier.EndTable();
2471   }
2472 };
2473
2474 template <>
2475 inline const onert_tflite::CustomQuantization *
2476 QuantizationParameters::details_as<onert_tflite::CustomQuantization>() const
2477 {
2478   return details_as_CustomQuantization();
2479 }
2480
2481 struct QuantizationParametersBuilder
2482 {
2483   typedef QuantizationParameters Table;
2484   flatbuffers::FlatBufferBuilder &fbb_;
2485   flatbuffers::uoffset_t start_;
2486   void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min)
2487   {
2488     fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
2489   }
2490   void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max)
2491   {
2492     fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
2493   }
2494   void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale)
2495   {
2496     fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
2497   }
2498   void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point)
2499   {
2500     fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
2501   }
2502   void add_details_type(onert_tflite::QuantizationDetails details_type)
2503   {
2504     fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE,
2505                              static_cast<uint8_t>(details_type), 0);
2506   }
2507   void add_details(flatbuffers::Offset<void> details)
2508   {
2509     fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
2510   }
2511   void add_quantized_dimension(int32_t quantized_dimension)
2512   {
2513     fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension,
2514                              0);
2515   }
2516   explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2517   {
2518     start_ = fbb_.StartTable();
2519   }
2520   flatbuffers::Offset<QuantizationParameters> Finish()
2521   {
2522     const auto end = fbb_.EndTable(start_);
2523     auto o = flatbuffers::Offset<QuantizationParameters>(end);
2524     return o;
2525   }
2526 };
2527
2528 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
2529   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
2530   flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
2531   flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
2532   flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
2533   onert_tflite::QuantizationDetails details_type = onert_tflite::QuantizationDetails_NONE,
2534   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2535 {
2536   QuantizationParametersBuilder builder_(_fbb);
2537   builder_.add_quantized_dimension(quantized_dimension);
2538   builder_.add_details(details);
2539   builder_.add_zero_point(zero_point);
2540   builder_.add_scale(scale);
2541   builder_.add_max(max);
2542   builder_.add_min(min);
2543   builder_.add_details_type(details_type);
2544   return builder_.Finish();
2545 }
2546
2547 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
2548   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<float> *min = nullptr,
2549   const std::vector<float> *max = nullptr, const std::vector<float> *scale = nullptr,
2550   const std::vector<int64_t> *zero_point = nullptr,
2551   onert_tflite::QuantizationDetails details_type = onert_tflite::QuantizationDetails_NONE,
2552   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2553 {
2554   auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
2555   auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
2556   auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
2557   auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
2558   return onert_tflite::CreateQuantizationParameters(_fbb, min__, max__, scale__, zero_point__,
2559                                                     details_type, details, quantized_dimension);
2560 }
2561
2562 struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2563 {
2564   typedef Int32VectorBuilder Builder;
2565   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2566   {
2567     VT_VALUES = 4
2568   };
2569   const flatbuffers::Vector<int32_t> *values() const
2570   {
2571     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
2572   }
2573   bool Verify(flatbuffers::Verifier &verifier) const
2574   {
2575     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2576            verifier.VerifyVector(values()) && verifier.EndTable();
2577   }
2578 };
2579
2580 struct Int32VectorBuilder
2581 {
2582   typedef Int32Vector Table;
2583   flatbuffers::FlatBufferBuilder &fbb_;
2584   flatbuffers::uoffset_t start_;
2585   void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values)
2586   {
2587     fbb_.AddOffset(Int32Vector::VT_VALUES, values);
2588   }
2589   explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2590   {
2591     start_ = fbb_.StartTable();
2592   }
2593   flatbuffers::Offset<Int32Vector> Finish()
2594   {
2595     const auto end = fbb_.EndTable(start_);
2596     auto o = flatbuffers::Offset<Int32Vector>(end);
2597     return o;
2598   }
2599 };
2600
2601 inline flatbuffers::Offset<Int32Vector>
2602 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb,
2603                   flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0)
2604 {
2605   Int32VectorBuilder builder_(_fbb);
2606   builder_.add_values(values);
2607   return builder_.Finish();
2608 }
2609
2610 inline flatbuffers::Offset<Int32Vector>
2611 CreateInt32VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2612                         const std::vector<int32_t> *values = nullptr)
2613 {
2614   auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
2615   return onert_tflite::CreateInt32Vector(_fbb, values__);
2616 }
2617
2618 struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2619 {
2620   typedef Uint16VectorBuilder Builder;
2621   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2622   {
2623     VT_VALUES = 4
2624   };
2625   const flatbuffers::Vector<uint16_t> *values() const
2626   {
2627     return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
2628   }
2629   bool Verify(flatbuffers::Verifier &verifier) const
2630   {
2631     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2632            verifier.VerifyVector(values()) && verifier.EndTable();
2633   }
2634 };
2635
2636 struct Uint16VectorBuilder
2637 {
2638   typedef Uint16Vector Table;
2639   flatbuffers::FlatBufferBuilder &fbb_;
2640   flatbuffers::uoffset_t start_;
2641   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values)
2642   {
2643     fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
2644   }
2645   explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2646   {
2647     start_ = fbb_.StartTable();
2648   }
2649   flatbuffers::Offset<Uint16Vector> Finish()
2650   {
2651     const auto end = fbb_.EndTable(start_);
2652     auto o = flatbuffers::Offset<Uint16Vector>(end);
2653     return o;
2654   }
2655 };
2656
2657 inline flatbuffers::Offset<Uint16Vector>
2658 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb,
2659                    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0)
2660 {
2661   Uint16VectorBuilder builder_(_fbb);
2662   builder_.add_values(values);
2663   return builder_.Finish();
2664 }
2665
2666 inline flatbuffers::Offset<Uint16Vector>
2667 CreateUint16VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2668                          const std::vector<uint16_t> *values = nullptr)
2669 {
2670   if (values)
2671   {
2672     _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4);
2673   }
2674   auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
2675   return onert_tflite::CreateUint16Vector(_fbb, values__);
2676 }
2677
2678 struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2679 {
2680   typedef Uint8VectorBuilder Builder;
2681   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2682   {
2683     VT_VALUES = 4
2684   };
2685   const flatbuffers::Vector<uint8_t> *values() const
2686   {
2687     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
2688   }
2689   bool Verify(flatbuffers::Verifier &verifier) const
2690   {
2691     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2692            verifier.VerifyVector(values()) && verifier.EndTable();
2693   }
2694 };
2695
2696 struct Uint8VectorBuilder
2697 {
2698   typedef Uint8Vector Table;
2699   flatbuffers::FlatBufferBuilder &fbb_;
2700   flatbuffers::uoffset_t start_;
2701   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values)
2702   {
2703     fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
2704   }
2705   explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2706   {
2707     start_ = fbb_.StartTable();
2708   }
2709   flatbuffers::Offset<Uint8Vector> Finish()
2710   {
2711     const auto end = fbb_.EndTable(start_);
2712     auto o = flatbuffers::Offset<Uint8Vector>(end);
2713     return o;
2714   }
2715 };
2716
2717 inline flatbuffers::Offset<Uint8Vector>
2718 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb,
2719                   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0)
2720 {
2721   Uint8VectorBuilder builder_(_fbb);
2722   builder_.add_values(values);
2723   return builder_.Finish();
2724 }
2725
2726 inline flatbuffers::Offset<Uint8Vector>
2727 CreateUint8VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2728                         const std::vector<uint8_t> *values = nullptr)
2729 {
2730   if (values)
2731   {
2732     _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4);
2733   }
2734   auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
2735   return onert_tflite::CreateUint8Vector(_fbb, values__);
2736 }
2737
2738 struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2739 {
2740   typedef DimensionMetadataBuilder Builder;
2741   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2742   {
2743     VT_FORMAT = 4,
2744     VT_DENSE_SIZE = 6,
2745     VT_ARRAY_SEGMENTS_TYPE = 8,
2746     VT_ARRAY_SEGMENTS = 10,
2747     VT_ARRAY_INDICES_TYPE = 12,
2748     VT_ARRAY_INDICES = 14
2749   };
2750   onert_tflite::DimensionType format() const
2751   {
2752     return static_cast<onert_tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
2753   }
2754   int32_t dense_size() const { return GetField<int32_t>(VT_DENSE_SIZE, 0); }
2755   onert_tflite::SparseIndexVector array_segments_type() const
2756   {
2757     return static_cast<onert_tflite::SparseIndexVector>(
2758       GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
2759   }
2760   const void *array_segments() const { return GetPointer<const void *>(VT_ARRAY_SEGMENTS); }
2761   template <typename T> const T *array_segments_as() const;
2762   const onert_tflite::Int32Vector *array_segments_as_Int32Vector() const
2763   {
2764     return array_segments_type() == onert_tflite::SparseIndexVector_Int32Vector
2765              ? static_cast<const onert_tflite::Int32Vector *>(array_segments())
2766              : nullptr;
2767   }
2768   const onert_tflite::Uint16Vector *array_segments_as_Uint16Vector() const
2769   {
2770     return array_segments_type() == onert_tflite::SparseIndexVector_Uint16Vector
2771              ? static_cast<const onert_tflite::Uint16Vector *>(array_segments())
2772              : nullptr;
2773   }
2774   const onert_tflite::Uint8Vector *array_segments_as_Uint8Vector() const
2775   {
2776     return array_segments_type() == onert_tflite::SparseIndexVector_Uint8Vector
2777              ? static_cast<const onert_tflite::Uint8Vector *>(array_segments())
2778              : nullptr;
2779   }
2780   onert_tflite::SparseIndexVector array_indices_type() const
2781   {
2782     return static_cast<onert_tflite::SparseIndexVector>(
2783       GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
2784   }
2785   const void *array_indices() const { return GetPointer<const void *>(VT_ARRAY_INDICES); }
2786   template <typename T> const T *array_indices_as() const;
2787   const onert_tflite::Int32Vector *array_indices_as_Int32Vector() const
2788   {
2789     return array_indices_type() == onert_tflite::SparseIndexVector_Int32Vector
2790              ? static_cast<const onert_tflite::Int32Vector *>(array_indices())
2791              : nullptr;
2792   }
2793   const onert_tflite::Uint16Vector *array_indices_as_Uint16Vector() const
2794   {
2795     return array_indices_type() == onert_tflite::SparseIndexVector_Uint16Vector
2796              ? static_cast<const onert_tflite::Uint16Vector *>(array_indices())
2797              : nullptr;
2798   }
2799   const onert_tflite::Uint8Vector *array_indices_as_Uint8Vector() const
2800   {
2801     return array_indices_type() == onert_tflite::SparseIndexVector_Uint8Vector
2802              ? static_cast<const onert_tflite::Uint8Vector *>(array_indices())
2803              : nullptr;
2804   }
2805   bool Verify(flatbuffers::Verifier &verifier) const
2806   {
2807     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_FORMAT) &&
2808            VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
2809            VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
2810            VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
2811            VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
2812            VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
2813            VerifyOffset(verifier, VT_ARRAY_INDICES) &&
2814            VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
2815            verifier.EndTable();
2816   }
2817 };
2818
2819 template <>
2820 inline const onert_tflite::Int32Vector *
2821 DimensionMetadata::array_segments_as<onert_tflite::Int32Vector>() const
2822 {
2823   return array_segments_as_Int32Vector();
2824 }
2825
2826 template <>
2827 inline const onert_tflite::Uint16Vector *
2828 DimensionMetadata::array_segments_as<onert_tflite::Uint16Vector>() const
2829 {
2830   return array_segments_as_Uint16Vector();
2831 }
2832
2833 template <>
2834 inline const onert_tflite::Uint8Vector *
2835 DimensionMetadata::array_segments_as<onert_tflite::Uint8Vector>() const
2836 {
2837   return array_segments_as_Uint8Vector();
2838 }
2839
2840 template <>
2841 inline const onert_tflite::Int32Vector *
2842 DimensionMetadata::array_indices_as<onert_tflite::Int32Vector>() const
2843 {
2844   return array_indices_as_Int32Vector();
2845 }
2846
2847 template <>
2848 inline const onert_tflite::Uint16Vector *
2849 DimensionMetadata::array_indices_as<onert_tflite::Uint16Vector>() const
2850 {
2851   return array_indices_as_Uint16Vector();
2852 }
2853
2854 template <>
2855 inline const onert_tflite::Uint8Vector *
2856 DimensionMetadata::array_indices_as<onert_tflite::Uint8Vector>() const
2857 {
2858   return array_indices_as_Uint8Vector();
2859 }
2860
2861 struct DimensionMetadataBuilder
2862 {
2863   typedef DimensionMetadata Table;
2864   flatbuffers::FlatBufferBuilder &fbb_;
2865   flatbuffers::uoffset_t start_;
2866   void add_format(onert_tflite::DimensionType format)
2867   {
2868     fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
2869   }
2870   void add_dense_size(int32_t dense_size)
2871   {
2872     fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
2873   }
2874   void add_array_segments_type(onert_tflite::SparseIndexVector array_segments_type)
2875   {
2876     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE,
2877                              static_cast<uint8_t>(array_segments_type), 0);
2878   }
2879   void add_array_segments(flatbuffers::Offset<void> array_segments)
2880   {
2881     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
2882   }
2883   void add_array_indices_type(onert_tflite::SparseIndexVector array_indices_type)
2884   {
2885     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE,
2886                              static_cast<uint8_t>(array_indices_type), 0);
2887   }
2888   void add_array_indices(flatbuffers::Offset<void> array_indices)
2889   {
2890     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
2891   }
2892   explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2893   {
2894     start_ = fbb_.StartTable();
2895   }
2896   flatbuffers::Offset<DimensionMetadata> Finish()
2897   {
2898     const auto end = fbb_.EndTable(start_);
2899     auto o = flatbuffers::Offset<DimensionMetadata>(end);
2900     return o;
2901   }
2902 };
2903
2904 inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
2905   flatbuffers::FlatBufferBuilder &_fbb,
2906   onert_tflite::DimensionType format = onert_tflite::DimensionType_DENSE, int32_t dense_size = 0,
2907   onert_tflite::SparseIndexVector array_segments_type = onert_tflite::SparseIndexVector_NONE,
2908   flatbuffers::Offset<void> array_segments = 0,
2909   onert_tflite::SparseIndexVector array_indices_type = onert_tflite::SparseIndexVector_NONE,
2910   flatbuffers::Offset<void> array_indices = 0)
2911 {
2912   DimensionMetadataBuilder builder_(_fbb);
2913   builder_.add_array_indices(array_indices);
2914   builder_.add_array_segments(array_segments);
2915   builder_.add_dense_size(dense_size);
2916   builder_.add_array_indices_type(array_indices_type);
2917   builder_.add_array_segments_type(array_segments_type);
2918   builder_.add_format(format);
2919   return builder_.Finish();
2920 }
2921
2922 struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2923 {
2924   typedef SparsityParametersBuilder Builder;
2925   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2926   {
2927     VT_TRAVERSAL_ORDER = 4,
2928     VT_BLOCK_MAP = 6,
2929     VT_DIM_METADATA = 8
2930   };
2931   const flatbuffers::Vector<int32_t> *traversal_order() const
2932   {
2933     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
2934   }
2935   const flatbuffers::Vector<int32_t> *block_map() const
2936   {
2937     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
2938   }
2939   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::DimensionMetadata>> *
2940   dim_metadata() const
2941   {
2942     return GetPointer<
2943       const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::DimensionMetadata>> *>(
2944       VT_DIM_METADATA);
2945   }
2946   bool Verify(flatbuffers::Verifier &verifier) const
2947   {
2948     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
2949            verifier.VerifyVector(traversal_order()) && VerifyOffset(verifier, VT_BLOCK_MAP) &&
2950            verifier.VerifyVector(block_map()) && VerifyOffset(verifier, VT_DIM_METADATA) &&
2951            verifier.VerifyVector(dim_metadata()) && verifier.VerifyVectorOfTables(dim_metadata()) &&
2952            verifier.EndTable();
2953   }
2954 };
2955
2956 struct SparsityParametersBuilder
2957 {
2958   typedef SparsityParameters Table;
2959   flatbuffers::FlatBufferBuilder &fbb_;
2960   flatbuffers::uoffset_t start_;
2961   void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order)
2962   {
2963     fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
2964   }
2965   void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map)
2966   {
2967     fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
2968   }
2969   void add_dim_metadata(
2970     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::DimensionMetadata>>>
2971       dim_metadata)
2972   {
2973     fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
2974   }
2975   explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2976   {
2977     start_ = fbb_.StartTable();
2978   }
2979   flatbuffers::Offset<SparsityParameters> Finish()
2980   {
2981     const auto end = fbb_.EndTable(start_);
2982     auto o = flatbuffers::Offset<SparsityParameters>(end);
2983     return o;
2984   }
2985 };
2986
2987 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
2988   flatbuffers::FlatBufferBuilder &_fbb,
2989   flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
2990   flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
2991   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::DimensionMetadata>>>
2992     dim_metadata = 0)
2993 {
2994   SparsityParametersBuilder builder_(_fbb);
2995   builder_.add_dim_metadata(dim_metadata);
2996   builder_.add_block_map(block_map);
2997   builder_.add_traversal_order(traversal_order);
2998   return builder_.Finish();
2999 }
3000
3001 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
3002   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *traversal_order = nullptr,
3003   const std::vector<int32_t> *block_map = nullptr,
3004   const std::vector<flatbuffers::Offset<onert_tflite::DimensionMetadata>> *dim_metadata = nullptr)
3005 {
3006   auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
3007   auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
3008   auto dim_metadata__ =
3009     dim_metadata
3010       ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::DimensionMetadata>>(*dim_metadata)
3011       : 0;
3012   return onert_tflite::CreateSparsityParameters(_fbb, traversal_order__, block_map__,
3013                                                 dim_metadata__);
3014 }
3015
3016 struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3017 {
3018   typedef TensorBuilder Builder;
3019   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3020   {
3021     VT_SHAPE = 4,
3022     VT_TYPE = 6,
3023     VT_BUFFER = 8,
3024     VT_NAME = 10,
3025     VT_QUANTIZATION = 12,
3026     VT_IS_VARIABLE = 14,
3027     VT_SPARSITY = 16,
3028     VT_SHAPE_SIGNATURE = 18,
3029     VT_HAS_RANK = 20
3030   };
3031   const flatbuffers::Vector<int32_t> *shape() const
3032   {
3033     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
3034   }
3035   onert_tflite::TensorType type() const
3036   {
3037     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
3038   }
3039   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
3040   const flatbuffers::String *name() const
3041   {
3042     return GetPointer<const flatbuffers::String *>(VT_NAME);
3043   }
3044   const onert_tflite::QuantizationParameters *quantization() const
3045   {
3046     return GetPointer<const onert_tflite::QuantizationParameters *>(VT_QUANTIZATION);
3047   }
3048   bool is_variable() const { return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0; }
3049   const onert_tflite::SparsityParameters *sparsity() const
3050   {
3051     return GetPointer<const onert_tflite::SparsityParameters *>(VT_SPARSITY);
3052   }
3053   const flatbuffers::Vector<int32_t> *shape_signature() const
3054   {
3055     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
3056   }
3057   bool has_rank() const { return GetField<uint8_t>(VT_HAS_RANK, 0) != 0; }
3058   bool Verify(flatbuffers::Verifier &verifier) const
3059   {
3060     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) &&
3061            verifier.VerifyVector(shape()) && VerifyField<int8_t>(verifier, VT_TYPE) &&
3062            VerifyField<uint32_t>(verifier, VT_BUFFER) && VerifyOffset(verifier, VT_NAME) &&
3063            verifier.VerifyString(name()) && VerifyOffset(verifier, VT_QUANTIZATION) &&
3064            verifier.VerifyTable(quantization()) && VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
3065            VerifyOffset(verifier, VT_SPARSITY) && verifier.VerifyTable(sparsity()) &&
3066            VerifyOffset(verifier, VT_SHAPE_SIGNATURE) && verifier.VerifyVector(shape_signature()) &&
3067            VerifyField<uint8_t>(verifier, VT_HAS_RANK) && verifier.EndTable();
3068   }
3069 };
3070
3071 struct TensorBuilder
3072 {
3073   typedef Tensor Table;
3074   flatbuffers::FlatBufferBuilder &fbb_;
3075   flatbuffers::uoffset_t start_;
3076   void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape)
3077   {
3078     fbb_.AddOffset(Tensor::VT_SHAPE, shape);
3079   }
3080   void add_type(onert_tflite::TensorType type)
3081   {
3082     fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
3083   }
3084   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0); }
3085   void add_name(flatbuffers::Offset<flatbuffers::String> name)
3086   {
3087     fbb_.AddOffset(Tensor::VT_NAME, name);
3088   }
3089   void add_quantization(flatbuffers::Offset<onert_tflite::QuantizationParameters> quantization)
3090   {
3091     fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
3092   }
3093   void add_is_variable(bool is_variable)
3094   {
3095     fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
3096   }
3097   void add_sparsity(flatbuffers::Offset<onert_tflite::SparsityParameters> sparsity)
3098   {
3099     fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
3100   }
3101   void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature)
3102   {
3103     fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
3104   }
3105   void add_has_rank(bool has_rank)
3106   {
3107     fbb_.AddElement<uint8_t>(Tensor::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
3108   }
3109   explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3110   {
3111     start_ = fbb_.StartTable();
3112   }
3113   flatbuffers::Offset<Tensor> Finish()
3114   {
3115     const auto end = fbb_.EndTable(start_);
3116     auto o = flatbuffers::Offset<Tensor>(end);
3117     return o;
3118   }
3119 };
3120
3121 inline flatbuffers::Offset<Tensor> CreateTensor(
3122   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
3123   onert_tflite::TensorType type = onert_tflite::TensorType_FLOAT32, uint32_t buffer = 0,
3124   flatbuffers::Offset<flatbuffers::String> name = 0,
3125   flatbuffers::Offset<onert_tflite::QuantizationParameters> quantization = 0,
3126   bool is_variable = false, flatbuffers::Offset<onert_tflite::SparsityParameters> sparsity = 0,
3127   flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0, bool has_rank = false)
3128 {
3129   TensorBuilder builder_(_fbb);
3130   builder_.add_shape_signature(shape_signature);
3131   builder_.add_sparsity(sparsity);
3132   builder_.add_quantization(quantization);
3133   builder_.add_name(name);
3134   builder_.add_buffer(buffer);
3135   builder_.add_shape(shape);
3136   builder_.add_has_rank(has_rank);
3137   builder_.add_is_variable(is_variable);
3138   builder_.add_type(type);
3139   return builder_.Finish();
3140 }
3141
3142 inline flatbuffers::Offset<Tensor> CreateTensorDirect(
3143   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *shape = nullptr,
3144   onert_tflite::TensorType type = onert_tflite::TensorType_FLOAT32, uint32_t buffer = 0,
3145   const char *name = nullptr,
3146   flatbuffers::Offset<onert_tflite::QuantizationParameters> quantization = 0,
3147   bool is_variable = false, flatbuffers::Offset<onert_tflite::SparsityParameters> sparsity = 0,
3148   const std::vector<int32_t> *shape_signature = nullptr, bool has_rank = false)
3149 {
3150   auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
3151   auto name__ = name ? _fbb.CreateString(name) : 0;
3152   auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
3153   return onert_tflite::CreateTensor(_fbb, shape__, type, buffer, name__, quantization, is_variable,
3154                                     sparsity, shape_signature__, has_rank);
3155 }
3156
3157 struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3158 {
3159   typedef Conv2DOptionsBuilder Builder;
3160   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3161   {
3162     VT_PADDING = 4,
3163     VT_STRIDE_W = 6,
3164     VT_STRIDE_H = 8,
3165     VT_FUSED_ACTIVATION_FUNCTION = 10,
3166     VT_DILATION_W_FACTOR = 12,
3167     VT_DILATION_H_FACTOR = 14
3168   };
3169   onert_tflite::Padding padding() const
3170   {
3171     return static_cast<onert_tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
3172   }
3173   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3174   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3175   onert_tflite::ActivationFunctionType fused_activation_function() const
3176   {
3177     return static_cast<onert_tflite::ActivationFunctionType>(
3178       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3179   }
3180   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
3181   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
3182   bool Verify(flatbuffers::Verifier &verifier) const
3183   {
3184     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3185            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3186            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3187            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3188            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3189            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
3190   }
3191 };
3192
3193 struct Conv2DOptionsBuilder
3194 {
3195   typedef Conv2DOptions Table;
3196   flatbuffers::FlatBufferBuilder &fbb_;
3197   flatbuffers::uoffset_t start_;
3198   void add_padding(onert_tflite::Padding padding)
3199   {
3200     fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3201   }
3202   void add_stride_w(int32_t stride_w)
3203   {
3204     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
3205   }
3206   void add_stride_h(int32_t stride_h)
3207   {
3208     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
3209   }
3210   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3211   {
3212     fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3213                             static_cast<int8_t>(fused_activation_function), 0);
3214   }
3215   void add_dilation_w_factor(int32_t dilation_w_factor)
3216   {
3217     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
3218   }
3219   void add_dilation_h_factor(int32_t dilation_h_factor)
3220   {
3221     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
3222   }
3223   explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3224   {
3225     start_ = fbb_.StartTable();
3226   }
3227   flatbuffers::Offset<Conv2DOptions> Finish()
3228   {
3229     const auto end = fbb_.EndTable(start_);
3230     auto o = flatbuffers::Offset<Conv2DOptions>(end);
3231     return o;
3232   }
3233 };
3234
3235 inline flatbuffers::Offset<Conv2DOptions>
3236 CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb,
3237                     onert_tflite::Padding padding = onert_tflite::Padding_SAME,
3238                     int32_t stride_w = 0, int32_t stride_h = 0,
3239                     onert_tflite::ActivationFunctionType fused_activation_function =
3240                       onert_tflite::ActivationFunctionType_NONE,
3241                     int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
3242 {
3243   Conv2DOptionsBuilder builder_(_fbb);
3244   builder_.add_dilation_h_factor(dilation_h_factor);
3245   builder_.add_dilation_w_factor(dilation_w_factor);
3246   builder_.add_stride_h(stride_h);
3247   builder_.add_stride_w(stride_w);
3248   builder_.add_fused_activation_function(fused_activation_function);
3249   builder_.add_padding(padding);
3250   return builder_.Finish();
3251 }
3252
3253 struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3254 {
3255   typedef Conv3DOptionsBuilder Builder;
3256   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3257   {
3258     VT_PADDING = 4,
3259     VT_STRIDE_D = 6,
3260     VT_STRIDE_W = 8,
3261     VT_STRIDE_H = 10,
3262     VT_FUSED_ACTIVATION_FUNCTION = 12,
3263     VT_DILATION_D_FACTOR = 14,
3264     VT_DILATION_W_FACTOR = 16,
3265     VT_DILATION_H_FACTOR = 18
3266   };
3267   onert_tflite::Padding padding() const
3268   {
3269     return static_cast<onert_tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
3270   }
3271   int32_t stride_d() const { return GetField<int32_t>(VT_STRIDE_D, 0); }
3272   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3273   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3274   onert_tflite::ActivationFunctionType fused_activation_function() const
3275   {
3276     return static_cast<onert_tflite::ActivationFunctionType>(
3277       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3278   }
3279   int32_t dilation_d_factor() const { return GetField<int32_t>(VT_DILATION_D_FACTOR, 1); }
3280   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
3281   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
3282   bool Verify(flatbuffers::Verifier &verifier) const
3283   {
3284     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3285            VerifyField<int32_t>(verifier, VT_STRIDE_D) &&
3286            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3287            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3288            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3289            VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR) &&
3290            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3291            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
3292   }
3293 };
3294
3295 struct Conv3DOptionsBuilder
3296 {
3297   typedef Conv3DOptions Table;
3298   flatbuffers::FlatBufferBuilder &fbb_;
3299   flatbuffers::uoffset_t start_;
3300   void add_padding(onert_tflite::Padding padding)
3301   {
3302     fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3303   }
3304   void add_stride_d(int32_t stride_d)
3305   {
3306     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, 0);
3307   }
3308   void add_stride_w(int32_t stride_w)
3309   {
3310     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, 0);
3311   }
3312   void add_stride_h(int32_t stride_h)
3313   {
3314     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, 0);
3315   }
3316   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3317   {
3318     fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3319                             static_cast<int8_t>(fused_activation_function), 0);
3320   }
3321   void add_dilation_d_factor(int32_t dilation_d_factor)
3322   {
3323     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, 1);
3324   }
3325   void add_dilation_w_factor(int32_t dilation_w_factor)
3326   {
3327     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
3328   }
3329   void add_dilation_h_factor(int32_t dilation_h_factor)
3330   {
3331     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
3332   }
3333   explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3334   {
3335     start_ = fbb_.StartTable();
3336   }
3337   flatbuffers::Offset<Conv3DOptions> Finish()
3338   {
3339     const auto end = fbb_.EndTable(start_);
3340     auto o = flatbuffers::Offset<Conv3DOptions>(end);
3341     return o;
3342   }
3343 };
3344
3345 inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
3346   flatbuffers::FlatBufferBuilder &_fbb, onert_tflite::Padding padding = onert_tflite::Padding_SAME,
3347   int32_t stride_d = 0, int32_t stride_w = 0, int32_t stride_h = 0,
3348   onert_tflite::ActivationFunctionType fused_activation_function =
3349     onert_tflite::ActivationFunctionType_NONE,
3350   int32_t dilation_d_factor = 1, int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
3351 {
3352   Conv3DOptionsBuilder builder_(_fbb);
3353   builder_.add_dilation_h_factor(dilation_h_factor);
3354   builder_.add_dilation_w_factor(dilation_w_factor);
3355   builder_.add_dilation_d_factor(dilation_d_factor);
3356   builder_.add_stride_h(stride_h);
3357   builder_.add_stride_w(stride_w);
3358   builder_.add_stride_d(stride_d);
3359   builder_.add_fused_activation_function(fused_activation_function);
3360   builder_.add_padding(padding);
3361   return builder_.Finish();
3362 }
3363
3364 struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3365 {
3366   typedef Pool2DOptionsBuilder Builder;
3367   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3368   {
3369     VT_PADDING = 4,
3370     VT_STRIDE_W = 6,
3371     VT_STRIDE_H = 8,
3372     VT_FILTER_WIDTH = 10,
3373     VT_FILTER_HEIGHT = 12,
3374     VT_FUSED_ACTIVATION_FUNCTION = 14
3375   };
3376   onert_tflite::Padding padding() const
3377   {
3378     return static_cast<onert_tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
3379   }
3380   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3381   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3382   int32_t filter_width() const { return GetField<int32_t>(VT_FILTER_WIDTH, 0); }
3383   int32_t filter_height() const { return GetField<int32_t>(VT_FILTER_HEIGHT, 0); }
3384   onert_tflite::ActivationFunctionType fused_activation_function() const
3385   {
3386     return static_cast<onert_tflite::ActivationFunctionType>(
3387       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3388   }
3389   bool Verify(flatbuffers::Verifier &verifier) const
3390   {
3391     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3392            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3393            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3394            VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
3395            VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
3396            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3397   }
3398 };
3399
3400 struct Pool2DOptionsBuilder
3401 {
3402   typedef Pool2DOptions Table;
3403   flatbuffers::FlatBufferBuilder &fbb_;
3404   flatbuffers::uoffset_t start_;
3405   void add_padding(onert_tflite::Padding padding)
3406   {
3407     fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3408   }
3409   void add_stride_w(int32_t stride_w)
3410   {
3411     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
3412   }
3413   void add_stride_h(int32_t stride_h)
3414   {
3415     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
3416   }
3417   void add_filter_width(int32_t filter_width)
3418   {
3419     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
3420   }
3421   void add_filter_height(int32_t filter_height)
3422   {
3423     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
3424   }
3425   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3426   {
3427     fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3428                             static_cast<int8_t>(fused_activation_function), 0);
3429   }
3430   explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3431   {
3432     start_ = fbb_.StartTable();
3433   }
3434   flatbuffers::Offset<Pool2DOptions> Finish()
3435   {
3436     const auto end = fbb_.EndTable(start_);
3437     auto o = flatbuffers::Offset<Pool2DOptions>(end);
3438     return o;
3439   }
3440 };
3441
3442 inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
3443   flatbuffers::FlatBufferBuilder &_fbb, onert_tflite::Padding padding = onert_tflite::Padding_SAME,
3444   int32_t stride_w = 0, int32_t stride_h = 0, int32_t filter_width = 0, int32_t filter_height = 0,
3445   onert_tflite::ActivationFunctionType fused_activation_function =
3446     onert_tflite::ActivationFunctionType_NONE)
3447 {
3448   Pool2DOptionsBuilder builder_(_fbb);
3449   builder_.add_filter_height(filter_height);
3450   builder_.add_filter_width(filter_width);
3451   builder_.add_stride_h(stride_h);
3452   builder_.add_stride_w(stride_w);
3453   builder_.add_fused_activation_function(fused_activation_function);
3454   builder_.add_padding(padding);
3455   return builder_.Finish();
3456 }
3457
3458 struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3459 {
3460   typedef DepthwiseConv2DOptionsBuilder Builder;
3461   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3462   {
3463     VT_PADDING = 4,
3464     VT_STRIDE_W = 6,
3465     VT_STRIDE_H = 8,
3466     VT_DEPTH_MULTIPLIER = 10,
3467     VT_FUSED_ACTIVATION_FUNCTION = 12,
3468     VT_DILATION_W_FACTOR = 14,
3469     VT_DILATION_H_FACTOR = 16
3470   };
3471   onert_tflite::Padding padding() const
3472   {
3473     return static_cast<onert_tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
3474   }
3475   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3476   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3477   int32_t depth_multiplier() const { return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0); }
3478   onert_tflite::ActivationFunctionType fused_activation_function() const
3479   {
3480     return static_cast<onert_tflite::ActivationFunctionType>(
3481       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3482   }
3483   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
3484   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
3485   bool Verify(flatbuffers::Verifier &verifier) const
3486   {
3487     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3488            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3489            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3490            VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
3491            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3492            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3493            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
3494   }
3495 };
3496
3497 struct DepthwiseConv2DOptionsBuilder
3498 {
3499   typedef DepthwiseConv2DOptions Table;
3500   flatbuffers::FlatBufferBuilder &fbb_;
3501   flatbuffers::uoffset_t start_;
3502   void add_padding(onert_tflite::Padding padding)
3503   {
3504     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3505   }
3506   void add_stride_w(int32_t stride_w)
3507   {
3508     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
3509   }
3510   void add_stride_h(int32_t stride_h)
3511   {
3512     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
3513   }
3514   void add_depth_multiplier(int32_t depth_multiplier)
3515   {
3516     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
3517   }
3518   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3519   {
3520     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3521                             static_cast<int8_t>(fused_activation_function), 0);
3522   }
3523   void add_dilation_w_factor(int32_t dilation_w_factor)
3524   {
3525     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
3526   }
3527   void add_dilation_h_factor(int32_t dilation_h_factor)
3528   {
3529     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
3530   }
3531   explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3532   {
3533     start_ = fbb_.StartTable();
3534   }
3535   flatbuffers::Offset<DepthwiseConv2DOptions> Finish()
3536   {
3537     const auto end = fbb_.EndTable(start_);
3538     auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
3539     return o;
3540   }
3541 };
3542
3543 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
3544   flatbuffers::FlatBufferBuilder &_fbb, onert_tflite::Padding padding = onert_tflite::Padding_SAME,
3545   int32_t stride_w = 0, int32_t stride_h = 0, int32_t depth_multiplier = 0,
3546   onert_tflite::ActivationFunctionType fused_activation_function =
3547     onert_tflite::ActivationFunctionType_NONE,
3548   int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
3549 {
3550   DepthwiseConv2DOptionsBuilder builder_(_fbb);
3551   builder_.add_dilation_h_factor(dilation_h_factor);
3552   builder_.add_dilation_w_factor(dilation_w_factor);
3553   builder_.add_depth_multiplier(depth_multiplier);
3554   builder_.add_stride_h(stride_h);
3555   builder_.add_stride_w(stride_w);
3556   builder_.add_fused_activation_function(fused_activation_function);
3557   builder_.add_padding(padding);
3558   return builder_.Finish();
3559 }
3560
3561 struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3562 {
3563   typedef ConcatEmbeddingsOptionsBuilder Builder;
3564   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3565   {
3566     VT_NUM_CHANNELS = 4,
3567     VT_NUM_COLUMNS_PER_CHANNEL = 6,
3568     VT_EMBEDDING_DIM_PER_CHANNEL = 8
3569   };
3570   int32_t num_channels() const { return GetField<int32_t>(VT_NUM_CHANNELS, 0); }
3571   const flatbuffers::Vector<int32_t> *num_columns_per_channel() const
3572   {
3573     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
3574   }
3575   const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const
3576   {
3577     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
3578   }
3579   bool Verify(flatbuffers::Verifier &verifier) const
3580   {
3581     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
3582            VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
3583            verifier.VerifyVector(num_columns_per_channel()) &&
3584            VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
3585            verifier.VerifyVector(embedding_dim_per_channel()) && verifier.EndTable();
3586   }
3587 };
3588
3589 struct ConcatEmbeddingsOptionsBuilder
3590 {
3591   typedef ConcatEmbeddingsOptions Table;
3592   flatbuffers::FlatBufferBuilder &fbb_;
3593   flatbuffers::uoffset_t start_;
3594   void add_num_channels(int32_t num_channels)
3595   {
3596     fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
3597   }
3598   void add_num_columns_per_channel(
3599     flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel)
3600   {
3601     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
3602   }
3603   void add_embedding_dim_per_channel(
3604     flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel)
3605   {
3606     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL,
3607                    embedding_dim_per_channel);
3608   }
3609   explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3610   {
3611     start_ = fbb_.StartTable();
3612   }
3613   flatbuffers::Offset<ConcatEmbeddingsOptions> Finish()
3614   {
3615     const auto end = fbb_.EndTable(start_);
3616     auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
3617     return o;
3618   }
3619 };
3620
3621 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
3622   flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
3623   flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
3624   flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0)
3625 {
3626   ConcatEmbeddingsOptionsBuilder builder_(_fbb);
3627   builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
3628   builder_.add_num_columns_per_channel(num_columns_per_channel);
3629   builder_.add_num_channels(num_channels);
3630   return builder_.Finish();
3631 }
3632
3633 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
3634 CreateConcatEmbeddingsOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
3635                                     const std::vector<int32_t> *num_columns_per_channel = nullptr,
3636                                     const std::vector<int32_t> *embedding_dim_per_channel = nullptr)
3637 {
3638   auto num_columns_per_channel__ =
3639     num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
3640   auto embedding_dim_per_channel__ =
3641     embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
3642   return onert_tflite::CreateConcatEmbeddingsOptions(_fbb, num_channels, num_columns_per_channel__,
3643                                                      embedding_dim_per_channel__);
3644 }
3645
3646 struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3647 {
3648   typedef LSHProjectionOptionsBuilder Builder;
3649   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3650   {
3651     VT_TYPE = 4
3652   };
3653   onert_tflite::LSHProjectionType type() const
3654   {
3655     return static_cast<onert_tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
3656   }
3657   bool Verify(flatbuffers::Verifier &verifier) const
3658   {
3659     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_TYPE) &&
3660            verifier.EndTable();
3661   }
3662 };
3663
3664 struct LSHProjectionOptionsBuilder
3665 {
3666   typedef LSHProjectionOptions Table;
3667   flatbuffers::FlatBufferBuilder &fbb_;
3668   flatbuffers::uoffset_t start_;
3669   void add_type(onert_tflite::LSHProjectionType type)
3670   {
3671     fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
3672   }
3673   explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3674   {
3675     start_ = fbb_.StartTable();
3676   }
3677   flatbuffers::Offset<LSHProjectionOptions> Finish()
3678   {
3679     const auto end = fbb_.EndTable(start_);
3680     auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
3681     return o;
3682   }
3683 };
3684
3685 inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
3686   flatbuffers::FlatBufferBuilder &_fbb,
3687   onert_tflite::LSHProjectionType type = onert_tflite::LSHProjectionType_UNKNOWN)
3688 {
3689   LSHProjectionOptionsBuilder builder_(_fbb);
3690   builder_.add_type(type);
3691   return builder_.Finish();
3692 }
3693
3694 struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3695 {
3696   typedef SVDFOptionsBuilder Builder;
3697   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3698   {
3699     VT_RANK = 4,
3700     VT_FUSED_ACTIVATION_FUNCTION = 6,
3701     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3702   };
3703   int32_t rank() const { return GetField<int32_t>(VT_RANK, 0); }
3704   onert_tflite::ActivationFunctionType fused_activation_function() const
3705   {
3706     return static_cast<onert_tflite::ActivationFunctionType>(
3707       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3708   }
3709   bool asymmetric_quantize_inputs() const
3710   {
3711     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3712   }
3713   bool Verify(flatbuffers::Verifier &verifier) const
3714   {
3715     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RANK) &&
3716            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3717            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3718   }
3719 };
3720
3721 struct SVDFOptionsBuilder
3722 {
3723   typedef SVDFOptions Table;
3724   flatbuffers::FlatBufferBuilder &fbb_;
3725   flatbuffers::uoffset_t start_;
3726   void add_rank(int32_t rank) { fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0); }
3727   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3728   {
3729     fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION,
3730                             static_cast<int8_t>(fused_activation_function), 0);
3731   }
3732   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3733   {
3734     fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3735                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3736   }
3737   explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3738   {
3739     start_ = fbb_.StartTable();
3740   }
3741   flatbuffers::Offset<SVDFOptions> Finish()
3742   {
3743     const auto end = fbb_.EndTable(start_);
3744     auto o = flatbuffers::Offset<SVDFOptions>(end);
3745     return o;
3746   }
3747 };
3748
3749 inline flatbuffers::Offset<SVDFOptions>
3750 CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0,
3751                   onert_tflite::ActivationFunctionType fused_activation_function =
3752                     onert_tflite::ActivationFunctionType_NONE,
3753                   bool asymmetric_quantize_inputs = false)
3754 {
3755   SVDFOptionsBuilder builder_(_fbb);
3756   builder_.add_rank(rank);
3757   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3758   builder_.add_fused_activation_function(fused_activation_function);
3759   return builder_.Finish();
3760 }
3761
3762 struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3763 {
3764   typedef RNNOptionsBuilder Builder;
3765   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3766   {
3767     VT_FUSED_ACTIVATION_FUNCTION = 4,
3768     VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
3769   };
3770   onert_tflite::ActivationFunctionType fused_activation_function() const
3771   {
3772     return static_cast<onert_tflite::ActivationFunctionType>(
3773       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3774   }
3775   bool asymmetric_quantize_inputs() const
3776   {
3777     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3778   }
3779   bool Verify(flatbuffers::Verifier &verifier) const
3780   {
3781     return VerifyTableStart(verifier) &&
3782            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3783            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3784   }
3785 };
3786
3787 struct RNNOptionsBuilder
3788 {
3789   typedef RNNOptions Table;
3790   flatbuffers::FlatBufferBuilder &fbb_;
3791   flatbuffers::uoffset_t start_;
3792   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3793   {
3794     fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3795                             static_cast<int8_t>(fused_activation_function), 0);
3796   }
3797   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3798   {
3799     fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3800                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3801   }
3802   explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3803   {
3804     start_ = fbb_.StartTable();
3805   }
3806   flatbuffers::Offset<RNNOptions> Finish()
3807   {
3808     const auto end = fbb_.EndTable(start_);
3809     auto o = flatbuffers::Offset<RNNOptions>(end);
3810     return o;
3811   }
3812 };
3813
3814 inline flatbuffers::Offset<RNNOptions>
3815 CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb,
3816                  onert_tflite::ActivationFunctionType fused_activation_function =
3817                    onert_tflite::ActivationFunctionType_NONE,
3818                  bool asymmetric_quantize_inputs = false)
3819 {
3820   RNNOptionsBuilder builder_(_fbb);
3821   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3822   builder_.add_fused_activation_function(fused_activation_function);
3823   return builder_.Finish();
3824 }
3825
3826 struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3827 {
3828   typedef SequenceRNNOptionsBuilder Builder;
3829   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3830   {
3831     VT_TIME_MAJOR = 4,
3832     VT_FUSED_ACTIVATION_FUNCTION = 6,
3833     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3834   };
3835   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3836   onert_tflite::ActivationFunctionType fused_activation_function() const
3837   {
3838     return static_cast<onert_tflite::ActivationFunctionType>(
3839       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3840   }
3841   bool asymmetric_quantize_inputs() const
3842   {
3843     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3844   }
3845   bool Verify(flatbuffers::Verifier &verifier) const
3846   {
3847     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3848            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3849            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3850   }
3851 };
3852
3853 struct SequenceRNNOptionsBuilder
3854 {
3855   typedef SequenceRNNOptions Table;
3856   flatbuffers::FlatBufferBuilder &fbb_;
3857   flatbuffers::uoffset_t start_;
3858   void add_time_major(bool time_major)
3859   {
3860     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major),
3861                              0);
3862   }
3863   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3864   {
3865     fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3866                             static_cast<int8_t>(fused_activation_function), 0);
3867   }
3868   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3869   {
3870     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3871                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3872   }
3873   explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3874   {
3875     start_ = fbb_.StartTable();
3876   }
3877   flatbuffers::Offset<SequenceRNNOptions> Finish()
3878   {
3879     const auto end = fbb_.EndTable(start_);
3880     auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
3881     return o;
3882   }
3883 };
3884
3885 inline flatbuffers::Offset<SequenceRNNOptions>
3886 CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3887                          onert_tflite::ActivationFunctionType fused_activation_function =
3888                            onert_tflite::ActivationFunctionType_NONE,
3889                          bool asymmetric_quantize_inputs = false)
3890 {
3891   SequenceRNNOptionsBuilder builder_(_fbb);
3892   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3893   builder_.add_fused_activation_function(fused_activation_function);
3894   builder_.add_time_major(time_major);
3895   return builder_.Finish();
3896 }
3897
3898 struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3899 {
3900   typedef BidirectionalSequenceRNNOptionsBuilder Builder;
3901   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3902   {
3903     VT_TIME_MAJOR = 4,
3904     VT_FUSED_ACTIVATION_FUNCTION = 6,
3905     VT_MERGE_OUTPUTS = 8,
3906     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3907   };
3908   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3909   onert_tflite::ActivationFunctionType fused_activation_function() const
3910   {
3911     return static_cast<onert_tflite::ActivationFunctionType>(
3912       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3913   }
3914   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
3915   bool asymmetric_quantize_inputs() const
3916   {
3917     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3918   }
3919   bool Verify(flatbuffers::Verifier &verifier) const
3920   {
3921     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3922            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3923            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
3924            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3925   }
3926 };
3927
3928 struct BidirectionalSequenceRNNOptionsBuilder
3929 {
3930   typedef BidirectionalSequenceRNNOptions Table;
3931   flatbuffers::FlatBufferBuilder &fbb_;
3932   flatbuffers::uoffset_t start_;
3933   void add_time_major(bool time_major)
3934   {
3935     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR,
3936                              static_cast<uint8_t>(time_major), 0);
3937   }
3938   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
3939   {
3940     fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3941                             static_cast<int8_t>(fused_activation_function), 0);
3942   }
3943   void add_merge_outputs(bool merge_outputs)
3944   {
3945     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS,
3946                              static_cast<uint8_t>(merge_outputs), 0);
3947   }
3948   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3949   {
3950     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3951                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3952   }
3953   explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3954   {
3955     start_ = fbb_.StartTable();
3956   }
3957   flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish()
3958   {
3959     const auto end = fbb_.EndTable(start_);
3960     auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
3961     return o;
3962   }
3963 };
3964
3965 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
3966   flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3967   onert_tflite::ActivationFunctionType fused_activation_function =
3968     onert_tflite::ActivationFunctionType_NONE,
3969   bool merge_outputs = false, bool asymmetric_quantize_inputs = false)
3970 {
3971   BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
3972   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3973   builder_.add_merge_outputs(merge_outputs);
3974   builder_.add_fused_activation_function(fused_activation_function);
3975   builder_.add_time_major(time_major);
3976   return builder_.Finish();
3977 }
3978
3979 struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3980 {
3981   typedef FullyConnectedOptionsBuilder Builder;
3982   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3983   {
3984     VT_FUSED_ACTIVATION_FUNCTION = 4,
3985     VT_WEIGHTS_FORMAT = 6,
3986     VT_KEEP_NUM_DIMS = 8,
3987     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3988   };
3989   onert_tflite::ActivationFunctionType fused_activation_function() const
3990   {
3991     return static_cast<onert_tflite::ActivationFunctionType>(
3992       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3993   }
3994   onert_tflite::FullyConnectedOptionsWeightsFormat weights_format() const
3995   {
3996     return static_cast<onert_tflite::FullyConnectedOptionsWeightsFormat>(
3997       GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
3998   }
3999   bool keep_num_dims() const { return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0; }
4000   bool asymmetric_quantize_inputs() const
4001   {
4002     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4003   }
4004   bool Verify(flatbuffers::Verifier &verifier) const
4005   {
4006     return VerifyTableStart(verifier) &&
4007            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4008            VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
4009            VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
4010            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4011   }
4012 };
4013
4014 struct FullyConnectedOptionsBuilder
4015 {
4016   typedef FullyConnectedOptions Table;
4017   flatbuffers::FlatBufferBuilder &fbb_;
4018   flatbuffers::uoffset_t start_;
4019   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4020   {
4021     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
4022                             static_cast<int8_t>(fused_activation_function), 0);
4023   }
4024   void add_weights_format(onert_tflite::FullyConnectedOptionsWeightsFormat weights_format)
4025   {
4026     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT,
4027                             static_cast<int8_t>(weights_format), 0);
4028   }
4029   void add_keep_num_dims(bool keep_num_dims)
4030   {
4031     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS,
4032                              static_cast<uint8_t>(keep_num_dims), 0);
4033   }
4034   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4035   {
4036     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4037                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4038   }
4039   explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4040   {
4041     start_ = fbb_.StartTable();
4042   }
4043   flatbuffers::Offset<FullyConnectedOptions> Finish()
4044   {
4045     const auto end = fbb_.EndTable(start_);
4046     auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
4047     return o;
4048   }
4049 };
4050
4051 inline flatbuffers::Offset<FullyConnectedOptions>
4052 CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb,
4053                             onert_tflite::ActivationFunctionType fused_activation_function =
4054                               onert_tflite::ActivationFunctionType_NONE,
4055                             onert_tflite::FullyConnectedOptionsWeightsFormat weights_format =
4056                               onert_tflite::FullyConnectedOptionsWeightsFormat_DEFAULT,
4057                             bool keep_num_dims = false, bool asymmetric_quantize_inputs = false)
4058 {
4059   FullyConnectedOptionsBuilder builder_(_fbb);
4060   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4061   builder_.add_keep_num_dims(keep_num_dims);
4062   builder_.add_weights_format(weights_format);
4063   builder_.add_fused_activation_function(fused_activation_function);
4064   return builder_.Finish();
4065 }
4066
4067 struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4068 {
4069   typedef SoftmaxOptionsBuilder Builder;
4070   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4071   {
4072     VT_BETA = 4
4073   };
4074   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
4075   bool Verify(flatbuffers::Verifier &verifier) const
4076   {
4077     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_BETA) &&
4078            verifier.EndTable();
4079   }
4080 };
4081
4082 struct SoftmaxOptionsBuilder
4083 {
4084   typedef SoftmaxOptions Table;
4085   flatbuffers::FlatBufferBuilder &fbb_;
4086   flatbuffers::uoffset_t start_;
4087   void add_beta(float beta) { fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f); }
4088   explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4089   {
4090     start_ = fbb_.StartTable();
4091   }
4092   flatbuffers::Offset<SoftmaxOptions> Finish()
4093   {
4094     const auto end = fbb_.EndTable(start_);
4095     auto o = flatbuffers::Offset<SoftmaxOptions>(end);
4096     return o;
4097   }
4098 };
4099
4100 inline flatbuffers::Offset<SoftmaxOptions>
4101 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f)
4102 {
4103   SoftmaxOptionsBuilder builder_(_fbb);
4104   builder_.add_beta(beta);
4105   return builder_.Finish();
4106 }
4107
4108 struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4109 {
4110   typedef ConcatenationOptionsBuilder Builder;
4111   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4112   {
4113     VT_AXIS = 4,
4114     VT_FUSED_ACTIVATION_FUNCTION = 6
4115   };
4116   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
4117   onert_tflite::ActivationFunctionType fused_activation_function() const
4118   {
4119     return static_cast<onert_tflite::ActivationFunctionType>(
4120       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4121   }
4122   bool Verify(flatbuffers::Verifier &verifier) const
4123   {
4124     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
4125            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4126   }
4127 };
4128
4129 struct ConcatenationOptionsBuilder
4130 {
4131   typedef ConcatenationOptions Table;
4132   flatbuffers::FlatBufferBuilder &fbb_;
4133   flatbuffers::uoffset_t start_;
4134   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0); }
4135   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4136   {
4137     fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION,
4138                             static_cast<int8_t>(fused_activation_function), 0);
4139   }
4140   explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4141   {
4142     start_ = fbb_.StartTable();
4143   }
4144   flatbuffers::Offset<ConcatenationOptions> Finish()
4145   {
4146     const auto end = fbb_.EndTable(start_);
4147     auto o = flatbuffers::Offset<ConcatenationOptions>(end);
4148     return o;
4149   }
4150 };
4151
4152 inline flatbuffers::Offset<ConcatenationOptions>
4153 CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0,
4154                            onert_tflite::ActivationFunctionType fused_activation_function =
4155                              onert_tflite::ActivationFunctionType_NONE)
4156 {
4157   ConcatenationOptionsBuilder builder_(_fbb);
4158   builder_.add_axis(axis);
4159   builder_.add_fused_activation_function(fused_activation_function);
4160   return builder_.Finish();
4161 }
4162
4163 struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4164 {
4165   typedef AddOptionsBuilder Builder;
4166   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4167   {
4168     VT_FUSED_ACTIVATION_FUNCTION = 4,
4169     VT_POT_SCALE_INT16 = 6
4170   };
4171   onert_tflite::ActivationFunctionType fused_activation_function() const
4172   {
4173     return static_cast<onert_tflite::ActivationFunctionType>(
4174       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4175   }
4176   bool pot_scale_int16() const { return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0; }
4177   bool Verify(flatbuffers::Verifier &verifier) const
4178   {
4179     return VerifyTableStart(verifier) &&
4180            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4181            VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) && verifier.EndTable();
4182   }
4183 };
4184
4185 struct AddOptionsBuilder
4186 {
4187   typedef AddOptions Table;
4188   flatbuffers::FlatBufferBuilder &fbb_;
4189   flatbuffers::uoffset_t start_;
4190   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4191   {
4192     fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION,
4193                             static_cast<int8_t>(fused_activation_function), 0);
4194   }
4195   void add_pot_scale_int16(bool pot_scale_int16)
4196   {
4197     fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16),
4198                              1);
4199   }
4200   explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4201   {
4202     start_ = fbb_.StartTable();
4203   }
4204   flatbuffers::Offset<AddOptions> Finish()
4205   {
4206     const auto end = fbb_.EndTable(start_);
4207     auto o = flatbuffers::Offset<AddOptions>(end);
4208     return o;
4209   }
4210 };
4211
4212 inline flatbuffers::Offset<AddOptions>
4213 CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb,
4214                  onert_tflite::ActivationFunctionType fused_activation_function =
4215                    onert_tflite::ActivationFunctionType_NONE,
4216                  bool pot_scale_int16 = true)
4217 {
4218   AddOptionsBuilder builder_(_fbb);
4219   builder_.add_pot_scale_int16(pot_scale_int16);
4220   builder_.add_fused_activation_function(fused_activation_function);
4221   return builder_.Finish();
4222 }
4223
4224 struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4225 {
4226   typedef MulOptionsBuilder Builder;
4227   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4228   {
4229     VT_FUSED_ACTIVATION_FUNCTION = 4
4230   };
4231   onert_tflite::ActivationFunctionType fused_activation_function() const
4232   {
4233     return static_cast<onert_tflite::ActivationFunctionType>(
4234       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4235   }
4236   bool Verify(flatbuffers::Verifier &verifier) const
4237   {
4238     return VerifyTableStart(verifier) &&
4239            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4240   }
4241 };
4242
4243 struct MulOptionsBuilder
4244 {
4245   typedef MulOptions Table;
4246   flatbuffers::FlatBufferBuilder &fbb_;
4247   flatbuffers::uoffset_t start_;
4248   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4249   {
4250     fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION,
4251                             static_cast<int8_t>(fused_activation_function), 0);
4252   }
4253   explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4254   {
4255     start_ = fbb_.StartTable();
4256   }
4257   flatbuffers::Offset<MulOptions> Finish()
4258   {
4259     const auto end = fbb_.EndTable(start_);
4260     auto o = flatbuffers::Offset<MulOptions>(end);
4261     return o;
4262   }
4263 };
4264
4265 inline flatbuffers::Offset<MulOptions>
4266 CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb,
4267                  onert_tflite::ActivationFunctionType fused_activation_function =
4268                    onert_tflite::ActivationFunctionType_NONE)
4269 {
4270   MulOptionsBuilder builder_(_fbb);
4271   builder_.add_fused_activation_function(fused_activation_function);
4272   return builder_.Finish();
4273 }
4274
4275 struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4276 {
4277   typedef L2NormOptionsBuilder Builder;
4278   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4279   {
4280     VT_FUSED_ACTIVATION_FUNCTION = 4
4281   };
4282   onert_tflite::ActivationFunctionType fused_activation_function() const
4283   {
4284     return static_cast<onert_tflite::ActivationFunctionType>(
4285       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4286   }
4287   bool Verify(flatbuffers::Verifier &verifier) const
4288   {
4289     return VerifyTableStart(verifier) &&
4290            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4291   }
4292 };
4293
4294 struct L2NormOptionsBuilder
4295 {
4296   typedef L2NormOptions Table;
4297   flatbuffers::FlatBufferBuilder &fbb_;
4298   flatbuffers::uoffset_t start_;
4299   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4300   {
4301     fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION,
4302                             static_cast<int8_t>(fused_activation_function), 0);
4303   }
4304   explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4305   {
4306     start_ = fbb_.StartTable();
4307   }
4308   flatbuffers::Offset<L2NormOptions> Finish()
4309   {
4310     const auto end = fbb_.EndTable(start_);
4311     auto o = flatbuffers::Offset<L2NormOptions>(end);
4312     return o;
4313   }
4314 };
4315
4316 inline flatbuffers::Offset<L2NormOptions>
4317 CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb,
4318                     onert_tflite::ActivationFunctionType fused_activation_function =
4319                       onert_tflite::ActivationFunctionType_NONE)
4320 {
4321   L2NormOptionsBuilder builder_(_fbb);
4322   builder_.add_fused_activation_function(fused_activation_function);
4323   return builder_.Finish();
4324 }
4325
4326 struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4327 {
4328   typedef LocalResponseNormalizationOptionsBuilder Builder;
4329   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4330   {
4331     VT_RADIUS = 4,
4332     VT_BIAS = 6,
4333     VT_ALPHA = 8,
4334     VT_BETA = 10
4335   };
4336   int32_t radius() const { return GetField<int32_t>(VT_RADIUS, 0); }
4337   float bias() const { return GetField<float>(VT_BIAS, 0.0f); }
4338   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
4339   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
4340   bool Verify(flatbuffers::Verifier &verifier) const
4341   {
4342     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RADIUS) &&
4343            VerifyField<float>(verifier, VT_BIAS) && VerifyField<float>(verifier, VT_ALPHA) &&
4344            VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
4345   }
4346 };
4347
4348 struct LocalResponseNormalizationOptionsBuilder
4349 {
4350   typedef LocalResponseNormalizationOptions Table;
4351   flatbuffers::FlatBufferBuilder &fbb_;
4352   flatbuffers::uoffset_t start_;
4353   void add_radius(int32_t radius)
4354   {
4355     fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
4356   }
4357   void add_bias(float bias)
4358   {
4359     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
4360   }
4361   void add_alpha(float alpha)
4362   {
4363     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
4364   }
4365   void add_beta(float beta)
4366   {
4367     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
4368   }
4369   explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4370     : fbb_(_fbb)
4371   {
4372     start_ = fbb_.StartTable();
4373   }
4374   flatbuffers::Offset<LocalResponseNormalizationOptions> Finish()
4375   {
4376     const auto end = fbb_.EndTable(start_);
4377     auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
4378     return o;
4379   }
4380 };
4381
4382 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
4383 CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t radius = 0,
4384                                         float bias = 0.0f, float alpha = 0.0f, float beta = 0.0f)
4385 {
4386   LocalResponseNormalizationOptionsBuilder builder_(_fbb);
4387   builder_.add_beta(beta);
4388   builder_.add_alpha(alpha);
4389   builder_.add_bias(bias);
4390   builder_.add_radius(radius);
4391   return builder_.Finish();
4392 }
4393
4394 struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4395 {
4396   typedef LSTMOptionsBuilder Builder;
4397   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4398   {
4399     VT_FUSED_ACTIVATION_FUNCTION = 4,
4400     VT_CELL_CLIP = 6,
4401     VT_PROJ_CLIP = 8,
4402     VT_KERNEL_TYPE = 10,
4403     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
4404   };
4405   onert_tflite::ActivationFunctionType fused_activation_function() const
4406   {
4407     return static_cast<onert_tflite::ActivationFunctionType>(
4408       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4409   }
4410   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4411   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4412   onert_tflite::LSTMKernelType kernel_type() const
4413   {
4414     return static_cast<onert_tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
4415   }
4416   bool asymmetric_quantize_inputs() const
4417   {
4418     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4419   }
4420   bool Verify(flatbuffers::Verifier &verifier) const
4421   {
4422     return VerifyTableStart(verifier) &&
4423            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4424            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4425            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4426            VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
4427            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4428   }
4429 };
4430
4431 struct LSTMOptionsBuilder
4432 {
4433   typedef LSTMOptions Table;
4434   flatbuffers::FlatBufferBuilder &fbb_;
4435   flatbuffers::uoffset_t start_;
4436   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4437   {
4438     fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4439                             static_cast<int8_t>(fused_activation_function), 0);
4440   }
4441   void add_cell_clip(float cell_clip)
4442   {
4443     fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4444   }
4445   void add_proj_clip(float proj_clip)
4446   {
4447     fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4448   }
4449   void add_kernel_type(onert_tflite::LSTMKernelType kernel_type)
4450   {
4451     fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
4452   }
4453   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4454   {
4455     fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4456                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4457   }
4458   explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4459   {
4460     start_ = fbb_.StartTable();
4461   }
4462   flatbuffers::Offset<LSTMOptions> Finish()
4463   {
4464     const auto end = fbb_.EndTable(start_);
4465     auto o = flatbuffers::Offset<LSTMOptions>(end);
4466     return o;
4467   }
4468 };
4469
4470 inline flatbuffers::Offset<LSTMOptions>
4471 CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb,
4472                   onert_tflite::ActivationFunctionType fused_activation_function =
4473                     onert_tflite::ActivationFunctionType_NONE,
4474                   float cell_clip = 0.0f, float proj_clip = 0.0f,
4475                   onert_tflite::LSTMKernelType kernel_type = onert_tflite::LSTMKernelType_FULL,
4476                   bool asymmetric_quantize_inputs = false)
4477 {
4478   LSTMOptionsBuilder builder_(_fbb);
4479   builder_.add_proj_clip(proj_clip);
4480   builder_.add_cell_clip(cell_clip);
4481   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4482   builder_.add_kernel_type(kernel_type);
4483   builder_.add_fused_activation_function(fused_activation_function);
4484   return builder_.Finish();
4485 }
4486
4487 struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4488 {
4489   typedef UnidirectionalSequenceLSTMOptionsBuilder Builder;
4490   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4491   {
4492     VT_FUSED_ACTIVATION_FUNCTION = 4,
4493     VT_CELL_CLIP = 6,
4494     VT_PROJ_CLIP = 8,
4495     VT_TIME_MAJOR = 10,
4496     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
4497   };
4498   onert_tflite::ActivationFunctionType fused_activation_function() const
4499   {
4500     return static_cast<onert_tflite::ActivationFunctionType>(
4501       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4502   }
4503   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4504   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4505   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
4506   bool asymmetric_quantize_inputs() const
4507   {
4508     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4509   }
4510   bool Verify(flatbuffers::Verifier &verifier) const
4511   {
4512     return VerifyTableStart(verifier) &&
4513            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4514            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4515            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4516            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4517            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4518   }
4519 };
4520
4521 struct UnidirectionalSequenceLSTMOptionsBuilder
4522 {
4523   typedef UnidirectionalSequenceLSTMOptions Table;
4524   flatbuffers::FlatBufferBuilder &fbb_;
4525   flatbuffers::uoffset_t start_;
4526   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4527   {
4528     fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4529                             static_cast<int8_t>(fused_activation_function), 0);
4530   }
4531   void add_cell_clip(float cell_clip)
4532   {
4533     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4534   }
4535   void add_proj_clip(float proj_clip)
4536   {
4537     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4538   }
4539   void add_time_major(bool time_major)
4540   {
4541     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
4542                              static_cast<uint8_t>(time_major), 0);
4543   }
4544   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4545   {
4546     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4547                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4548   }
4549   explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4550     : fbb_(_fbb)
4551   {
4552     start_ = fbb_.StartTable();
4553   }
4554   flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish()
4555   {
4556     const auto end = fbb_.EndTable(start_);
4557     auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
4558     return o;
4559   }
4560 };
4561
4562 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
4563 CreateUnidirectionalSequenceLSTMOptions(
4564   flatbuffers::FlatBufferBuilder &_fbb,
4565   onert_tflite::ActivationFunctionType fused_activation_function =
4566     onert_tflite::ActivationFunctionType_NONE,
4567   float cell_clip = 0.0f, float proj_clip = 0.0f, bool time_major = false,
4568   bool asymmetric_quantize_inputs = false)
4569 {
4570   UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
4571   builder_.add_proj_clip(proj_clip);
4572   builder_.add_cell_clip(cell_clip);
4573   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4574   builder_.add_time_major(time_major);
4575   builder_.add_fused_activation_function(fused_activation_function);
4576   return builder_.Finish();
4577 }
4578
4579 struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4580 {
4581   typedef BidirectionalSequenceLSTMOptionsBuilder Builder;
4582   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4583   {
4584     VT_FUSED_ACTIVATION_FUNCTION = 4,
4585     VT_CELL_CLIP = 6,
4586     VT_PROJ_CLIP = 8,
4587     VT_MERGE_OUTPUTS = 10,
4588     VT_TIME_MAJOR = 12,
4589     VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
4590   };
4591   onert_tflite::ActivationFunctionType fused_activation_function() const
4592   {
4593     return static_cast<onert_tflite::ActivationFunctionType>(
4594       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4595   }
4596   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4597   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4598   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
4599   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0; }
4600   bool asymmetric_quantize_inputs() const
4601   {
4602     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4603   }
4604   bool Verify(flatbuffers::Verifier &verifier) const
4605   {
4606     return VerifyTableStart(verifier) &&
4607            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4608            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4609            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4610            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
4611            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4612            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4613   }
4614 };
4615
4616 struct BidirectionalSequenceLSTMOptionsBuilder
4617 {
4618   typedef BidirectionalSequenceLSTMOptions Table;
4619   flatbuffers::FlatBufferBuilder &fbb_;
4620   flatbuffers::uoffset_t start_;
4621   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
4622   {
4623     fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4624                             static_cast<int8_t>(fused_activation_function), 0);
4625   }
4626   void add_cell_clip(float cell_clip)
4627   {
4628     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4629   }
4630   void add_proj_clip(float proj_clip)
4631   {
4632     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4633   }
4634   void add_merge_outputs(bool merge_outputs)
4635   {
4636     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS,
4637                              static_cast<uint8_t>(merge_outputs), 0);
4638   }
4639   void add_time_major(bool time_major)
4640   {
4641     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
4642                              static_cast<uint8_t>(time_major), 1);
4643   }
4644   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4645   {
4646     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4647                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4648   }
4649   explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4650     : fbb_(_fbb)
4651   {
4652     start_ = fbb_.StartTable();
4653   }
4654   flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish()
4655   {
4656     const auto end = fbb_.EndTable(start_);
4657     auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
4658     return o;
4659   }
4660 };
4661
4662 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
4663   flatbuffers::FlatBufferBuilder &_fbb,
4664   onert_tflite::ActivationFunctionType fused_activation_function =
4665     onert_tflite::ActivationFunctionType_NONE,
4666   float cell_clip = 0.0f, float proj_clip = 0.0f, bool merge_outputs = false,
4667   bool time_major = true, bool asymmetric_quantize_inputs = false)
4668 {
4669   BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
4670   builder_.add_proj_clip(proj_clip);
4671   builder_.add_cell_clip(cell_clip);
4672   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4673   builder_.add_time_major(time_major);
4674   builder_.add_merge_outputs(merge_outputs);
4675   builder_.add_fused_activation_function(fused_activation_function);
4676   return builder_.Finish();
4677 }
4678
4679 struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4680 {
4681   typedef ResizeBilinearOptionsBuilder Builder;
4682   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4683   {
4684     VT_ALIGN_CORNERS = 8,
4685     VT_HALF_PIXEL_CENTERS = 10
4686   };
4687   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
4688   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
4689   bool Verify(flatbuffers::Verifier &verifier) const
4690   {
4691     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
4692            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
4693   }
4694 };
4695
4696 struct ResizeBilinearOptionsBuilder
4697 {
4698   typedef ResizeBilinearOptions Table;
4699   flatbuffers::FlatBufferBuilder &fbb_;
4700   flatbuffers::uoffset_t start_;
4701   void add_align_corners(bool align_corners)
4702   {
4703     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS,
4704                              static_cast<uint8_t>(align_corners), 0);
4705   }
4706   void add_half_pixel_centers(bool half_pixel_centers)
4707   {
4708     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS,
4709                              static_cast<uint8_t>(half_pixel_centers), 0);
4710   }
4711   explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4712   {
4713     start_ = fbb_.StartTable();
4714   }
4715   flatbuffers::Offset<ResizeBilinearOptions> Finish()
4716   {
4717     const auto end = fbb_.EndTable(start_);
4718     auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
4719     return o;
4720   }
4721 };
4722
4723 inline flatbuffers::Offset<ResizeBilinearOptions>
4724 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
4725                             bool half_pixel_centers = false)
4726 {
4727   ResizeBilinearOptionsBuilder builder_(_fbb);
4728   builder_.add_half_pixel_centers(half_pixel_centers);
4729   builder_.add_align_corners(align_corners);
4730   return builder_.Finish();
4731 }
4732
4733 struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4734 {
4735   typedef ResizeNearestNeighborOptionsBuilder Builder;
4736   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4737   {
4738     VT_ALIGN_CORNERS = 4,
4739     VT_HALF_PIXEL_CENTERS = 6
4740   };
4741   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
4742   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
4743   bool Verify(flatbuffers::Verifier &verifier) const
4744   {
4745     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
4746            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
4747   }
4748 };
4749
4750 struct ResizeNearestNeighborOptionsBuilder
4751 {
4752   typedef ResizeNearestNeighborOptions Table;
4753   flatbuffers::FlatBufferBuilder &fbb_;
4754   flatbuffers::uoffset_t start_;
4755   void add_align_corners(bool align_corners)
4756   {
4757     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS,
4758                              static_cast<uint8_t>(align_corners), 0);
4759   }
4760   void add_half_pixel_centers(bool half_pixel_centers)
4761   {
4762     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS,
4763                              static_cast<uint8_t>(half_pixel_centers), 0);
4764   }
4765   explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4766   {
4767     start_ = fbb_.StartTable();
4768   }
4769   flatbuffers::Offset<ResizeNearestNeighborOptions> Finish()
4770   {
4771     const auto end = fbb_.EndTable(start_);
4772     auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
4773     return o;
4774   }
4775 };
4776
4777 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
4778 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
4779                                    bool half_pixel_centers = false)
4780 {
4781   ResizeNearestNeighborOptionsBuilder builder_(_fbb);
4782   builder_.add_half_pixel_centers(half_pixel_centers);
4783   builder_.add_align_corners(align_corners);
4784   return builder_.Finish();
4785 }
4786
4787 struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4788 {
4789   typedef CallOptionsBuilder Builder;
4790   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4791   {
4792     VT_SUBGRAPH = 4
4793   };
4794   uint32_t subgraph() const { return GetField<uint32_t>(VT_SUBGRAPH, 0); }
4795   bool Verify(flatbuffers::Verifier &verifier) const
4796   {
4797     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
4798            verifier.EndTable();
4799   }
4800 };
4801
4802 struct CallOptionsBuilder
4803 {
4804   typedef CallOptions Table;
4805   flatbuffers::FlatBufferBuilder &fbb_;
4806   flatbuffers::uoffset_t start_;
4807   void add_subgraph(uint32_t subgraph)
4808   {
4809     fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
4810   }
4811   explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4812   {
4813     start_ = fbb_.StartTable();
4814   }
4815   flatbuffers::Offset<CallOptions> Finish()
4816   {
4817     const auto end = fbb_.EndTable(start_);
4818     auto o = flatbuffers::Offset<CallOptions>(end);
4819     return o;
4820   }
4821 };
4822
4823 inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb,
4824                                                           uint32_t subgraph = 0)
4825 {
4826   CallOptionsBuilder builder_(_fbb);
4827   builder_.add_subgraph(subgraph);
4828   return builder_.Finish();
4829 }
4830
4831 struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4832 {
4833   typedef PadOptionsBuilder Builder;
4834   bool Verify(flatbuffers::Verifier &verifier) const
4835   {
4836     return VerifyTableStart(verifier) && verifier.EndTable();
4837   }
4838 };
4839
4840 struct PadOptionsBuilder
4841 {
4842   typedef PadOptions Table;
4843   flatbuffers::FlatBufferBuilder &fbb_;
4844   flatbuffers::uoffset_t start_;
4845   explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4846   {
4847     start_ = fbb_.StartTable();
4848   }
4849   flatbuffers::Offset<PadOptions> Finish()
4850   {
4851     const auto end = fbb_.EndTable(start_);
4852     auto o = flatbuffers::Offset<PadOptions>(end);
4853     return o;
4854   }
4855 };
4856
4857 inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb)
4858 {
4859   PadOptionsBuilder builder_(_fbb);
4860   return builder_.Finish();
4861 }
4862
4863 struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4864 {
4865   typedef PadV2OptionsBuilder Builder;
4866   bool Verify(flatbuffers::Verifier &verifier) const
4867   {
4868     return VerifyTableStart(verifier) && verifier.EndTable();
4869   }
4870 };
4871
4872 struct PadV2OptionsBuilder
4873 {
4874   typedef PadV2Options Table;
4875   flatbuffers::FlatBufferBuilder &fbb_;
4876   flatbuffers::uoffset_t start_;
4877   explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4878   {
4879     start_ = fbb_.StartTable();
4880   }
4881   flatbuffers::Offset<PadV2Options> Finish()
4882   {
4883     const auto end = fbb_.EndTable(start_);
4884     auto o = flatbuffers::Offset<PadV2Options>(end);
4885     return o;
4886   }
4887 };
4888
4889 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb)
4890 {
4891   PadV2OptionsBuilder builder_(_fbb);
4892   return builder_.Finish();
4893 }
4894
4895 struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4896 {
4897   typedef ReshapeOptionsBuilder Builder;
4898   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4899   {
4900     VT_NEW_SHAPE = 4
4901   };
4902   const flatbuffers::Vector<int32_t> *new_shape() const
4903   {
4904     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
4905   }
4906   bool Verify(flatbuffers::Verifier &verifier) const
4907   {
4908     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) &&
4909            verifier.VerifyVector(new_shape()) && verifier.EndTable();
4910   }
4911 };
4912
4913 struct ReshapeOptionsBuilder
4914 {
4915   typedef ReshapeOptions Table;
4916   flatbuffers::FlatBufferBuilder &fbb_;
4917   flatbuffers::uoffset_t start_;
4918   void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape)
4919   {
4920     fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
4921   }
4922   explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4923   {
4924     start_ = fbb_.StartTable();
4925   }
4926   flatbuffers::Offset<ReshapeOptions> Finish()
4927   {
4928     const auto end = fbb_.EndTable(start_);
4929     auto o = flatbuffers::Offset<ReshapeOptions>(end);
4930     return o;
4931   }
4932 };
4933
4934 inline flatbuffers::Offset<ReshapeOptions>
4935 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
4936                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0)
4937 {
4938   ReshapeOptionsBuilder builder_(_fbb);
4939   builder_.add_new_shape(new_shape);
4940   return builder_.Finish();
4941 }
4942
4943 inline flatbuffers::Offset<ReshapeOptions>
4944 CreateReshapeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
4945                            const std::vector<int32_t> *new_shape = nullptr)
4946 {
4947   auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
4948   return onert_tflite::CreateReshapeOptions(_fbb, new_shape__);
4949 }
4950
4951 struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4952 {
4953   typedef SpaceToBatchNDOptionsBuilder Builder;
4954   bool Verify(flatbuffers::Verifier &verifier) const
4955   {
4956     return VerifyTableStart(verifier) && verifier.EndTable();
4957   }
4958 };
4959
4960 struct SpaceToBatchNDOptionsBuilder
4961 {
4962   typedef SpaceToBatchNDOptions Table;
4963   flatbuffers::FlatBufferBuilder &fbb_;
4964   flatbuffers::uoffset_t start_;
4965   explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4966   {
4967     start_ = fbb_.StartTable();
4968   }
4969   flatbuffers::Offset<SpaceToBatchNDOptions> Finish()
4970   {
4971     const auto end = fbb_.EndTable(start_);
4972     auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
4973     return o;
4974   }
4975 };
4976
4977 inline flatbuffers::Offset<SpaceToBatchNDOptions>
4978 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
4979 {
4980   SpaceToBatchNDOptionsBuilder builder_(_fbb);
4981   return builder_.Finish();
4982 }
4983
4984 struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4985 {
4986   typedef BatchToSpaceNDOptionsBuilder Builder;
4987   bool Verify(flatbuffers::Verifier &verifier) const
4988   {
4989     return VerifyTableStart(verifier) && verifier.EndTable();
4990   }
4991 };
4992
4993 struct BatchToSpaceNDOptionsBuilder
4994 {
4995   typedef BatchToSpaceNDOptions Table;
4996   flatbuffers::FlatBufferBuilder &fbb_;
4997   flatbuffers::uoffset_t start_;
4998   explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4999   {
5000     start_ = fbb_.StartTable();
5001   }
5002   flatbuffers::Offset<BatchToSpaceNDOptions> Finish()
5003   {
5004     const auto end = fbb_.EndTable(start_);
5005     auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
5006     return o;
5007   }
5008 };
5009
5010 inline flatbuffers::Offset<BatchToSpaceNDOptions>
5011 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
5012 {
5013   BatchToSpaceNDOptionsBuilder builder_(_fbb);
5014   return builder_.Finish();
5015 }
5016
5017 struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5018 {
5019   typedef SkipGramOptionsBuilder Builder;
5020   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5021   {
5022     VT_NGRAM_SIZE = 4,
5023     VT_MAX_SKIP_SIZE = 6,
5024     VT_INCLUDE_ALL_NGRAMS = 8
5025   };
5026   int32_t ngram_size() const { return GetField<int32_t>(VT_NGRAM_SIZE, 0); }
5027   int32_t max_skip_size() const { return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0); }
5028   bool include_all_ngrams() const { return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0; }
5029   bool Verify(flatbuffers::Verifier &verifier) const
5030   {
5031     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
5032            VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
5033            VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) && verifier.EndTable();
5034   }
5035 };
5036
5037 struct SkipGramOptionsBuilder
5038 {
5039   typedef SkipGramOptions Table;
5040   flatbuffers::FlatBufferBuilder &fbb_;
5041   flatbuffers::uoffset_t start_;
5042   void add_ngram_size(int32_t ngram_size)
5043   {
5044     fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
5045   }
5046   void add_max_skip_size(int32_t max_skip_size)
5047   {
5048     fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
5049   }
5050   void add_include_all_ngrams(bool include_all_ngrams)
5051   {
5052     fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS,
5053                              static_cast<uint8_t>(include_all_ngrams), 0);
5054   }
5055   explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5056   {
5057     start_ = fbb_.StartTable();
5058   }
5059   flatbuffers::Offset<SkipGramOptions> Finish()
5060   {
5061     const auto end = fbb_.EndTable(start_);
5062     auto o = flatbuffers::Offset<SkipGramOptions>(end);
5063     return o;
5064   }
5065 };
5066
5067 inline flatbuffers::Offset<SkipGramOptions>
5068 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0,
5069                       int32_t max_skip_size = 0, bool include_all_ngrams = false)
5070 {
5071   SkipGramOptionsBuilder builder_(_fbb);
5072   builder_.add_max_skip_size(max_skip_size);
5073   builder_.add_ngram_size(ngram_size);
5074   builder_.add_include_all_ngrams(include_all_ngrams);
5075   return builder_.Finish();
5076 }
5077
5078 struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5079 {
5080   typedef SpaceToDepthOptionsBuilder Builder;
5081   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5082   {
5083     VT_BLOCK_SIZE = 4
5084   };
5085   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
5086   bool Verify(flatbuffers::Verifier &verifier) const
5087   {
5088     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
5089            verifier.EndTable();
5090   }
5091 };
5092
5093 struct SpaceToDepthOptionsBuilder
5094 {
5095   typedef SpaceToDepthOptions Table;
5096   flatbuffers::FlatBufferBuilder &fbb_;
5097   flatbuffers::uoffset_t start_;
5098   void add_block_size(int32_t block_size)
5099   {
5100     fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
5101   }
5102   explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5103   {
5104     start_ = fbb_.StartTable();
5105   }
5106   flatbuffers::Offset<SpaceToDepthOptions> Finish()
5107   {
5108     const auto end = fbb_.EndTable(start_);
5109     auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
5110     return o;
5111   }
5112 };
5113
5114 inline flatbuffers::Offset<SpaceToDepthOptions>
5115 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
5116 {
5117   SpaceToDepthOptionsBuilder builder_(_fbb);
5118   builder_.add_block_size(block_size);
5119   return builder_.Finish();
5120 }
5121
5122 struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5123 {
5124   typedef DepthToSpaceOptionsBuilder Builder;
5125   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5126   {
5127     VT_BLOCK_SIZE = 4
5128   };
5129   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
5130   bool Verify(flatbuffers::Verifier &verifier) const
5131   {
5132     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
5133            verifier.EndTable();
5134   }
5135 };
5136
5137 struct DepthToSpaceOptionsBuilder
5138 {
5139   typedef DepthToSpaceOptions Table;
5140   flatbuffers::FlatBufferBuilder &fbb_;
5141   flatbuffers::uoffset_t start_;
5142   void add_block_size(int32_t block_size)
5143   {
5144     fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
5145   }
5146   explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5147   {
5148     start_ = fbb_.StartTable();
5149   }
5150   flatbuffers::Offset<DepthToSpaceOptions> Finish()
5151   {
5152     const auto end = fbb_.EndTable(start_);
5153     auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
5154     return o;
5155   }
5156 };
5157
5158 inline flatbuffers::Offset<DepthToSpaceOptions>
5159 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
5160 {
5161   DepthToSpaceOptionsBuilder builder_(_fbb);
5162   builder_.add_block_size(block_size);
5163   return builder_.Finish();
5164 }
5165
5166 struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5167 {
5168   typedef SubOptionsBuilder Builder;
5169   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5170   {
5171     VT_FUSED_ACTIVATION_FUNCTION = 4,
5172     VT_POT_SCALE_INT16 = 6
5173   };
5174   onert_tflite::ActivationFunctionType fused_activation_function() const
5175   {
5176     return static_cast<onert_tflite::ActivationFunctionType>(
5177       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5178   }
5179   bool pot_scale_int16() const { return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0; }
5180   bool Verify(flatbuffers::Verifier &verifier) const
5181   {
5182     return VerifyTableStart(verifier) &&
5183            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5184            VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) && verifier.EndTable();
5185   }
5186 };
5187
5188 struct SubOptionsBuilder
5189 {
5190   typedef SubOptions Table;
5191   flatbuffers::FlatBufferBuilder &fbb_;
5192   flatbuffers::uoffset_t start_;
5193   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
5194   {
5195     fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION,
5196                             static_cast<int8_t>(fused_activation_function), 0);
5197   }
5198   void add_pot_scale_int16(bool pot_scale_int16)
5199   {
5200     fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16),
5201                              1);
5202   }
5203   explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5204   {
5205     start_ = fbb_.StartTable();
5206   }
5207   flatbuffers::Offset<SubOptions> Finish()
5208   {
5209     const auto end = fbb_.EndTable(start_);
5210     auto o = flatbuffers::Offset<SubOptions>(end);
5211     return o;
5212   }
5213 };
5214
5215 inline flatbuffers::Offset<SubOptions>
5216 CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb,
5217                  onert_tflite::ActivationFunctionType fused_activation_function =
5218                    onert_tflite::ActivationFunctionType_NONE,
5219                  bool pot_scale_int16 = true)
5220 {
5221   SubOptionsBuilder builder_(_fbb);
5222   builder_.add_pot_scale_int16(pot_scale_int16);
5223   builder_.add_fused_activation_function(fused_activation_function);
5224   return builder_.Finish();
5225 }
5226
5227 struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5228 {
5229   typedef DivOptionsBuilder Builder;
5230   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5231   {
5232     VT_FUSED_ACTIVATION_FUNCTION = 4
5233   };
5234   onert_tflite::ActivationFunctionType fused_activation_function() const
5235   {
5236     return static_cast<onert_tflite::ActivationFunctionType>(
5237       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5238   }
5239   bool Verify(flatbuffers::Verifier &verifier) const
5240   {
5241     return VerifyTableStart(verifier) &&
5242            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
5243   }
5244 };
5245
5246 struct DivOptionsBuilder
5247 {
5248   typedef DivOptions Table;
5249   flatbuffers::FlatBufferBuilder &fbb_;
5250   flatbuffers::uoffset_t start_;
5251   void add_fused_activation_function(onert_tflite::ActivationFunctionType fused_activation_function)
5252   {
5253     fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION,
5254                             static_cast<int8_t>(fused_activation_function), 0);
5255   }
5256   explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5257   {
5258     start_ = fbb_.StartTable();
5259   }
5260   flatbuffers::Offset<DivOptions> Finish()
5261   {
5262     const auto end = fbb_.EndTable(start_);
5263     auto o = flatbuffers::Offset<DivOptions>(end);
5264     return o;
5265   }
5266 };
5267
5268 inline flatbuffers::Offset<DivOptions>
5269 CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb,
5270                  onert_tflite::ActivationFunctionType fused_activation_function =
5271                    onert_tflite::ActivationFunctionType_NONE)
5272 {
5273   DivOptionsBuilder builder_(_fbb);
5274   builder_.add_fused_activation_function(fused_activation_function);
5275   return builder_.Finish();
5276 }
5277
5278 struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5279 {
5280   typedef TopKV2OptionsBuilder Builder;
5281   bool Verify(flatbuffers::Verifier &verifier) const
5282   {
5283     return VerifyTableStart(verifier) && verifier.EndTable();
5284   }
5285 };
5286
5287 struct TopKV2OptionsBuilder
5288 {
5289   typedef TopKV2Options Table;
5290   flatbuffers::FlatBufferBuilder &fbb_;
5291   flatbuffers::uoffset_t start_;
5292   explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5293   {
5294     start_ = fbb_.StartTable();
5295   }
5296   flatbuffers::Offset<TopKV2Options> Finish()
5297   {
5298     const auto end = fbb_.EndTable(start_);
5299     auto o = flatbuffers::Offset<TopKV2Options>(end);
5300     return o;
5301   }
5302 };
5303
5304 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb)
5305 {
5306   TopKV2OptionsBuilder builder_(_fbb);
5307   return builder_.Finish();
5308 }
5309
5310 struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5311 {
5312   typedef EmbeddingLookupSparseOptionsBuilder Builder;
5313   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5314   {
5315     VT_COMBINER = 4
5316   };
5317   onert_tflite::CombinerType combiner() const
5318   {
5319     return static_cast<onert_tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
5320   }
5321   bool Verify(flatbuffers::Verifier &verifier) const
5322   {
5323     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_COMBINER) &&
5324            verifier.EndTable();
5325   }
5326 };
5327
5328 struct EmbeddingLookupSparseOptionsBuilder
5329 {
5330   typedef EmbeddingLookupSparseOptions Table;
5331   flatbuffers::FlatBufferBuilder &fbb_;
5332   flatbuffers::uoffset_t start_;
5333   void add_combiner(onert_tflite::CombinerType combiner)
5334   {
5335     fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER,
5336                             static_cast<int8_t>(combiner), 0);
5337   }
5338   explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5339   {
5340     start_ = fbb_.StartTable();
5341   }
5342   flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish()
5343   {
5344     const auto end = fbb_.EndTable(start_);
5345     auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
5346     return o;
5347   }
5348 };
5349
5350 inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
5351   flatbuffers::FlatBufferBuilder &_fbb,
5352   onert_tflite::CombinerType combiner = onert_tflite::CombinerType_SUM)
5353 {
5354   EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
5355   builder_.add_combiner(combiner);
5356   return builder_.Finish();
5357 }
5358
5359 struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5360 {
5361   typedef GatherOptionsBuilder Builder;
5362   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5363   {
5364     VT_AXIS = 4,
5365     VT_BATCH_DIMS = 6
5366   };
5367   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
5368   int32_t batch_dims() const { return GetField<int32_t>(VT_BATCH_DIMS, 0); }
5369   bool Verify(flatbuffers::Verifier &verifier) const
5370   {
5371     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
5372            VerifyField<int32_t>(verifier, VT_BATCH_DIMS) && verifier.EndTable();
5373   }
5374 };
5375
5376 struct GatherOptionsBuilder
5377 {
5378   typedef GatherOptions Table;
5379   flatbuffers::FlatBufferBuilder &fbb_;
5380   flatbuffers::uoffset_t start_;
5381   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0); }
5382   void add_batch_dims(int32_t batch_dims)
5383   {
5384     fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
5385   }
5386   explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5387   {
5388     start_ = fbb_.StartTable();
5389   }
5390   flatbuffers::Offset<GatherOptions> Finish()
5391   {
5392     const auto end = fbb_.EndTable(start_);
5393     auto o = flatbuffers::Offset<GatherOptions>(end);
5394     return o;
5395   }
5396 };
5397
5398 inline flatbuffers::Offset<GatherOptions>
5399 CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0, int32_t batch_dims = 0)
5400 {
5401   GatherOptionsBuilder builder_(_fbb);
5402   builder_.add_batch_dims(batch_dims);
5403   builder_.add_axis(axis);
5404   return builder_.Finish();
5405 }
5406
5407 struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5408 {
5409   typedef TransposeOptionsBuilder Builder;
5410   bool Verify(flatbuffers::Verifier &verifier) const
5411   {
5412     return VerifyTableStart(verifier) && verifier.EndTable();
5413   }
5414 };
5415
5416 struct TransposeOptionsBuilder
5417 {
5418   typedef TransposeOptions Table;
5419   flatbuffers::FlatBufferBuilder &fbb_;
5420   flatbuffers::uoffset_t start_;
5421   explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5422   {
5423     start_ = fbb_.StartTable();
5424   }
5425   flatbuffers::Offset<TransposeOptions> Finish()
5426   {
5427     const auto end = fbb_.EndTable(start_);
5428     auto o = flatbuffers::Offset<TransposeOptions>(end);
5429     return o;
5430   }
5431 };
5432
5433 inline flatbuffers::Offset<TransposeOptions>
5434 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb)
5435 {
5436   TransposeOptionsBuilder builder_(_fbb);
5437   return builder_.Finish();
5438 }
5439
5440 struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5441 {
5442   typedef ExpOptionsBuilder Builder;
5443   bool Verify(flatbuffers::Verifier &verifier) const
5444   {
5445     return VerifyTableStart(verifier) && verifier.EndTable();
5446   }
5447 };
5448
5449 struct ExpOptionsBuilder
5450 {
5451   typedef ExpOptions Table;
5452   flatbuffers::FlatBufferBuilder &fbb_;
5453   flatbuffers::uoffset_t start_;
5454   explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5455   {
5456     start_ = fbb_.StartTable();
5457   }
5458   flatbuffers::Offset<ExpOptions> Finish()
5459   {
5460     const auto end = fbb_.EndTable(start_);
5461     auto o = flatbuffers::Offset<ExpOptions>(end);
5462     return o;
5463   }
5464 };
5465
5466 inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb)
5467 {
5468   ExpOptionsBuilder builder_(_fbb);
5469   return builder_.Finish();
5470 }
5471
5472 struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5473 {
5474   typedef CosOptionsBuilder Builder;
5475   bool Verify(flatbuffers::Verifier &verifier) const
5476   {
5477     return VerifyTableStart(verifier) && verifier.EndTable();
5478   }
5479 };
5480
5481 struct CosOptionsBuilder
5482 {
5483   typedef CosOptions Table;
5484   flatbuffers::FlatBufferBuilder &fbb_;
5485   flatbuffers::uoffset_t start_;
5486   explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5487   {
5488     start_ = fbb_.StartTable();
5489   }
5490   flatbuffers::Offset<CosOptions> Finish()
5491   {
5492     const auto end = fbb_.EndTable(start_);
5493     auto o = flatbuffers::Offset<CosOptions>(end);
5494     return o;
5495   }
5496 };
5497
5498 inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb)
5499 {
5500   CosOptionsBuilder builder_(_fbb);
5501   return builder_.Finish();
5502 }
5503
5504 struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5505 {
5506   typedef ReducerOptionsBuilder Builder;
5507   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5508   {
5509     VT_KEEP_DIMS = 4
5510   };
5511   bool keep_dims() const { return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; }
5512   bool Verify(flatbuffers::Verifier &verifier) const
5513   {
5514     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
5515            verifier.EndTable();
5516   }
5517 };
5518
5519 struct ReducerOptionsBuilder
5520 {
5521   typedef ReducerOptions Table;
5522   flatbuffers::FlatBufferBuilder &fbb_;
5523   flatbuffers::uoffset_t start_;
5524   void add_keep_dims(bool keep_dims)
5525   {
5526     fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
5527   }
5528   explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5529   {
5530     start_ = fbb_.StartTable();
5531   }
5532   flatbuffers::Offset<ReducerOptions> Finish()
5533   {
5534     const auto end = fbb_.EndTable(start_);
5535     auto o = flatbuffers::Offset<ReducerOptions>(end);
5536     return o;
5537   }
5538 };
5539
5540 inline flatbuffers::Offset<ReducerOptions>
5541 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false)
5542 {
5543   ReducerOptionsBuilder builder_(_fbb);
5544   builder_.add_keep_dims(keep_dims);
5545   return builder_.Finish();
5546 }
5547
5548 struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5549 {
5550   typedef SqueezeOptionsBuilder Builder;
5551   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5552   {
5553     VT_SQUEEZE_DIMS = 4
5554   };
5555   const flatbuffers::Vector<int32_t> *squeeze_dims() const
5556   {
5557     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
5558   }
5559   bool Verify(flatbuffers::Verifier &verifier) const
5560   {
5561     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
5562            verifier.VerifyVector(squeeze_dims()) && verifier.EndTable();
5563   }
5564 };
5565
5566 struct SqueezeOptionsBuilder
5567 {
5568   typedef SqueezeOptions Table;
5569   flatbuffers::FlatBufferBuilder &fbb_;
5570   flatbuffers::uoffset_t start_;
5571   void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims)
5572   {
5573     fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
5574   }
5575   explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5576   {
5577     start_ = fbb_.StartTable();
5578   }
5579   flatbuffers::Offset<SqueezeOptions> Finish()
5580   {
5581     const auto end = fbb_.EndTable(start_);
5582     auto o = flatbuffers::Offset<SqueezeOptions>(end);
5583     return o;
5584   }
5585 };
5586
5587 inline flatbuffers::Offset<SqueezeOptions>
5588 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb,
5589                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0)
5590 {
5591   SqueezeOptionsBuilder builder_(_fbb);
5592   builder_.add_squeeze_dims(squeeze_dims);
5593   return builder_.Finish();
5594 }
5595
5596 inline flatbuffers::Offset<SqueezeOptions>
5597 CreateSqueezeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
5598                            const std::vector<int32_t> *squeeze_dims = nullptr)
5599 {
5600   auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
5601   return onert_tflite::CreateSqueezeOptions(_fbb, squeeze_dims__);
5602 }
5603
5604 struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5605 {
5606   typedef SplitOptionsBuilder Builder;
5607   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5608   {
5609     VT_NUM_SPLITS = 4
5610   };
5611   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
5612   bool Verify(flatbuffers::Verifier &verifier) const
5613   {
5614     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
5615            verifier.EndTable();
5616   }
5617 };
5618
5619 struct SplitOptionsBuilder
5620 {
5621   typedef SplitOptions Table;
5622   flatbuffers::FlatBufferBuilder &fbb_;
5623   flatbuffers::uoffset_t start_;
5624   void add_num_splits(int32_t num_splits)
5625   {
5626     fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
5627   }
5628   explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5629   {
5630     start_ = fbb_.StartTable();
5631   }
5632   flatbuffers::Offset<SplitOptions> Finish()
5633   {
5634     const auto end = fbb_.EndTable(start_);
5635     auto o = flatbuffers::Offset<SplitOptions>(end);
5636     return o;
5637   }
5638 };
5639
5640 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb,
5641                                                             int32_t num_splits = 0)
5642 {
5643   SplitOptionsBuilder builder_(_fbb);
5644   builder_.add_num_splits(num_splits);
5645   return builder_.Finish();
5646 }
5647
5648 struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5649 {
5650   typedef SplitVOptionsBuilder Builder;
5651   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5652   {
5653     VT_NUM_SPLITS = 4
5654   };
5655   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
5656   bool Verify(flatbuffers::Verifier &verifier) const
5657   {
5658     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
5659            verifier.EndTable();
5660   }
5661 };
5662
5663 struct SplitVOptionsBuilder
5664 {
5665   typedef SplitVOptions Table;
5666   flatbuffers::FlatBufferBuilder &fbb_;
5667   flatbuffers::uoffset_t start_;
5668   void add_num_splits(int32_t num_splits)
5669   {
5670     fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
5671   }
5672   explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5673   {
5674     start_ = fbb_.StartTable();
5675   }
5676   flatbuffers::Offset<SplitVOptions> Finish()
5677   {
5678     const auto end = fbb_.EndTable(start_);
5679     auto o = flatbuffers::Offset<SplitVOptions>(end);
5680     return o;
5681   }
5682 };
5683
5684 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb,
5685                                                               int32_t num_splits = 0)
5686 {
5687   SplitVOptionsBuilder builder_(_fbb);
5688   builder_.add_num_splits(num_splits);
5689   return builder_.Finish();
5690 }
5691
5692 struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5693 {
5694   typedef StridedSliceOptionsBuilder Builder;
5695   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5696   {
5697     VT_BEGIN_MASK = 4,
5698     VT_END_MASK = 6,
5699     VT_ELLIPSIS_MASK = 8,
5700     VT_NEW_AXIS_MASK = 10,
5701     VT_SHRINK_AXIS_MASK = 12
5702   };
5703   int32_t begin_mask() const { return GetField<int32_t>(VT_BEGIN_MASK, 0); }
5704   int32_t end_mask() const { return GetField<int32_t>(VT_END_MASK, 0); }
5705   int32_t ellipsis_mask() const { return GetField<int32_t>(VT_ELLIPSIS_MASK, 0); }
5706   int32_t new_axis_mask() const { return GetField<int32_t>(VT_NEW_AXIS_MASK, 0); }
5707   int32_t shrink_axis_mask() const { return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0); }
5708   bool Verify(flatbuffers::Verifier &verifier) const
5709   {
5710     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
5711            VerifyField<int32_t>(verifier, VT_END_MASK) &&
5712            VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
5713            VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
5714            VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) && verifier.EndTable();
5715   }
5716 };
5717
5718 struct StridedSliceOptionsBuilder
5719 {
5720   typedef StridedSliceOptions Table;
5721   flatbuffers::FlatBufferBuilder &fbb_;
5722   flatbuffers::uoffset_t start_;
5723   void add_begin_mask(int32_t begin_mask)
5724   {
5725     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
5726   }
5727   void add_end_mask(int32_t end_mask)
5728   {
5729     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
5730   }
5731   void add_ellipsis_mask(int32_t ellipsis_mask)
5732   {
5733     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
5734   }
5735   void add_new_axis_mask(int32_t new_axis_mask)
5736   {
5737     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
5738   }
5739   void add_shrink_axis_mask(int32_t shrink_axis_mask)
5740   {
5741     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
5742   }
5743   explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5744   {
5745     start_ = fbb_.StartTable();
5746   }
5747   flatbuffers::Offset<StridedSliceOptions> Finish()
5748   {
5749     const auto end = fbb_.EndTable(start_);
5750     auto o = flatbuffers::Offset<StridedSliceOptions>(end);
5751     return o;
5752   }
5753 };
5754
5755 inline flatbuffers::Offset<StridedSliceOptions>
5756 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0,
5757                           int32_t end_mask = 0, int32_t ellipsis_mask = 0,
5758                           int32_t new_axis_mask = 0, int32_t shrink_axis_mask = 0)
5759 {
5760   StridedSliceOptionsBuilder builder_(_fbb);
5761   builder_.add_shrink_axis_mask(shrink_axis_mask);
5762   builder_.add_new_axis_mask(new_axis_mask);
5763   builder_.add_ellipsis_mask(ellipsis_mask);
5764   builder_.add_end_mask(end_mask);
5765   builder_.add_begin_mask(begin_mask);
5766   return builder_.Finish();
5767 }
5768
5769 struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5770 {
5771   typedef LogSoftmaxOptionsBuilder Builder;
5772   bool Verify(flatbuffers::Verifier &verifier) const
5773   {
5774     return VerifyTableStart(verifier) && verifier.EndTable();
5775   }
5776 };
5777
5778 struct LogSoftmaxOptionsBuilder
5779 {
5780   typedef LogSoftmaxOptions Table;
5781   flatbuffers::FlatBufferBuilder &fbb_;
5782   flatbuffers::uoffset_t start_;
5783   explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5784   {
5785     start_ = fbb_.StartTable();
5786   }
5787   flatbuffers::Offset<LogSoftmaxOptions> Finish()
5788   {
5789     const auto end = fbb_.EndTable(start_);
5790     auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
5791     return o;
5792   }
5793 };
5794
5795 inline flatbuffers::Offset<LogSoftmaxOptions>
5796 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
5797 {
5798   LogSoftmaxOptionsBuilder builder_(_fbb);
5799   return builder_.Finish();
5800 }
5801
5802 struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5803 {
5804   typedef CastOptionsBuilder Builder;
5805   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5806   {
5807     VT_IN_DATA_TYPE = 4,
5808     VT_OUT_DATA_TYPE = 6
5809   };
5810   onert_tflite::TensorType in_data_type() const
5811   {
5812     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
5813   }
5814   onert_tflite::TensorType out_data_type() const
5815   {
5816     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
5817   }
5818   bool Verify(flatbuffers::Verifier &verifier) const
5819   {
5820     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
5821            VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) && verifier.EndTable();
5822   }
5823 };
5824
5825 struct CastOptionsBuilder
5826 {
5827   typedef CastOptions Table;
5828   flatbuffers::FlatBufferBuilder &fbb_;
5829   flatbuffers::uoffset_t start_;
5830   void add_in_data_type(onert_tflite::TensorType in_data_type)
5831   {
5832     fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
5833   }
5834   void add_out_data_type(onert_tflite::TensorType out_data_type)
5835   {
5836     fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
5837   }
5838   explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5839   {
5840     start_ = fbb_.StartTable();
5841   }
5842   flatbuffers::Offset<CastOptions> Finish()
5843   {
5844     const auto end = fbb_.EndTable(start_);
5845     auto o = flatbuffers::Offset<CastOptions>(end);
5846     return o;
5847   }
5848 };
5849
5850 inline flatbuffers::Offset<CastOptions>
5851 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb,
5852                   onert_tflite::TensorType in_data_type = onert_tflite::TensorType_FLOAT32,
5853                   onert_tflite::TensorType out_data_type = onert_tflite::TensorType_FLOAT32)
5854 {
5855   CastOptionsBuilder builder_(_fbb);
5856   builder_.add_out_data_type(out_data_type);
5857   builder_.add_in_data_type(in_data_type);
5858   return builder_.Finish();
5859 }
5860
5861 struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5862 {
5863   typedef DequantizeOptionsBuilder Builder;
5864   bool Verify(flatbuffers::Verifier &verifier) const
5865   {
5866     return VerifyTableStart(verifier) && verifier.EndTable();
5867   }
5868 };
5869
5870 struct DequantizeOptionsBuilder
5871 {
5872   typedef DequantizeOptions Table;
5873   flatbuffers::FlatBufferBuilder &fbb_;
5874   flatbuffers::uoffset_t start_;
5875   explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5876   {
5877     start_ = fbb_.StartTable();
5878   }
5879   flatbuffers::Offset<DequantizeOptions> Finish()
5880   {
5881     const auto end = fbb_.EndTable(start_);
5882     auto o = flatbuffers::Offset<DequantizeOptions>(end);
5883     return o;
5884   }
5885 };
5886
5887 inline flatbuffers::Offset<DequantizeOptions>
5888 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
5889 {
5890   DequantizeOptionsBuilder builder_(_fbb);
5891   return builder_.Finish();
5892 }
5893
5894 struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5895 {
5896   typedef MaximumMinimumOptionsBuilder Builder;
5897   bool Verify(flatbuffers::Verifier &verifier) const
5898   {
5899     return VerifyTableStart(verifier) && verifier.EndTable();
5900   }
5901 };
5902
5903 struct MaximumMinimumOptionsBuilder
5904 {
5905   typedef MaximumMinimumOptions Table;
5906   flatbuffers::FlatBufferBuilder &fbb_;
5907   flatbuffers::uoffset_t start_;
5908   explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5909   {
5910     start_ = fbb_.StartTable();
5911   }
5912   flatbuffers::Offset<MaximumMinimumOptions> Finish()
5913   {
5914     const auto end = fbb_.EndTable(start_);
5915     auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
5916     return o;
5917   }
5918 };
5919
5920 inline flatbuffers::Offset<MaximumMinimumOptions>
5921 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb)
5922 {
5923   MaximumMinimumOptionsBuilder builder_(_fbb);
5924   return builder_.Finish();
5925 }
5926
5927 struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5928 {
5929   typedef TileOptionsBuilder Builder;
5930   bool Verify(flatbuffers::Verifier &verifier) const
5931   {
5932     return VerifyTableStart(verifier) && verifier.EndTable();
5933   }
5934 };
5935
5936 struct TileOptionsBuilder
5937 {
5938   typedef TileOptions Table;
5939   flatbuffers::FlatBufferBuilder &fbb_;
5940   flatbuffers::uoffset_t start_;
5941   explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5942   {
5943     start_ = fbb_.StartTable();
5944   }
5945   flatbuffers::Offset<TileOptions> Finish()
5946   {
5947     const auto end = fbb_.EndTable(start_);
5948     auto o = flatbuffers::Offset<TileOptions>(end);
5949     return o;
5950   }
5951 };
5952
5953 inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb)
5954 {
5955   TileOptionsBuilder builder_(_fbb);
5956   return builder_.Finish();
5957 }
5958
5959 struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5960 {
5961   typedef ArgMaxOptionsBuilder Builder;
5962   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5963   {
5964     VT_OUTPUT_TYPE = 4
5965   };
5966   onert_tflite::TensorType output_type() const
5967   {
5968     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
5969   }
5970   bool Verify(flatbuffers::Verifier &verifier) const
5971   {
5972     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
5973            verifier.EndTable();
5974   }
5975 };
5976
5977 struct ArgMaxOptionsBuilder
5978 {
5979   typedef ArgMaxOptions Table;
5980   flatbuffers::FlatBufferBuilder &fbb_;
5981   flatbuffers::uoffset_t start_;
5982   void add_output_type(onert_tflite::TensorType output_type)
5983   {
5984     fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
5985   }
5986   explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5987   {
5988     start_ = fbb_.StartTable();
5989   }
5990   flatbuffers::Offset<ArgMaxOptions> Finish()
5991   {
5992     const auto end = fbb_.EndTable(start_);
5993     auto o = flatbuffers::Offset<ArgMaxOptions>(end);
5994     return o;
5995   }
5996 };
5997
5998 inline flatbuffers::Offset<ArgMaxOptions>
5999 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb,
6000                     onert_tflite::TensorType output_type = onert_tflite::TensorType_FLOAT32)
6001 {
6002   ArgMaxOptionsBuilder builder_(_fbb);
6003   builder_.add_output_type(output_type);
6004   return builder_.Finish();
6005 }
6006
6007 struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6008 {
6009   typedef ArgMinOptionsBuilder Builder;
6010   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6011   {
6012     VT_OUTPUT_TYPE = 4
6013   };
6014   onert_tflite::TensorType output_type() const
6015   {
6016     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
6017   }
6018   bool Verify(flatbuffers::Verifier &verifier) const
6019   {
6020     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
6021            verifier.EndTable();
6022   }
6023 };
6024
6025 struct ArgMinOptionsBuilder
6026 {
6027   typedef ArgMinOptions Table;
6028   flatbuffers::FlatBufferBuilder &fbb_;
6029   flatbuffers::uoffset_t start_;
6030   void add_output_type(onert_tflite::TensorType output_type)
6031   {
6032     fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
6033   }
6034   explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6035   {
6036     start_ = fbb_.StartTable();
6037   }
6038   flatbuffers::Offset<ArgMinOptions> Finish()
6039   {
6040     const auto end = fbb_.EndTable(start_);
6041     auto o = flatbuffers::Offset<ArgMinOptions>(end);
6042     return o;
6043   }
6044 };
6045
6046 inline flatbuffers::Offset<ArgMinOptions>
6047 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb,
6048                     onert_tflite::TensorType output_type = onert_tflite::TensorType_FLOAT32)
6049 {
6050   ArgMinOptionsBuilder builder_(_fbb);
6051   builder_.add_output_type(output_type);
6052   return builder_.Finish();
6053 }
6054
6055 struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6056 {
6057   typedef GreaterOptionsBuilder Builder;
6058   bool Verify(flatbuffers::Verifier &verifier) const
6059   {
6060     return VerifyTableStart(verifier) && verifier.EndTable();
6061   }
6062 };
6063
6064 struct GreaterOptionsBuilder
6065 {
6066   typedef GreaterOptions Table;
6067   flatbuffers::FlatBufferBuilder &fbb_;
6068   flatbuffers::uoffset_t start_;
6069   explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6070   {
6071     start_ = fbb_.StartTable();
6072   }
6073   flatbuffers::Offset<GreaterOptions> Finish()
6074   {
6075     const auto end = fbb_.EndTable(start_);
6076     auto o = flatbuffers::Offset<GreaterOptions>(end);
6077     return o;
6078   }
6079 };
6080
6081 inline flatbuffers::Offset<GreaterOptions>
6082 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb)
6083 {
6084   GreaterOptionsBuilder builder_(_fbb);
6085   return builder_.Finish();
6086 }
6087
6088 struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6089 {
6090   typedef GreaterEqualOptionsBuilder Builder;
6091   bool Verify(flatbuffers::Verifier &verifier) const
6092   {
6093     return VerifyTableStart(verifier) && verifier.EndTable();
6094   }
6095 };
6096
6097 struct GreaterEqualOptionsBuilder
6098 {
6099   typedef GreaterEqualOptions Table;
6100   flatbuffers::FlatBufferBuilder &fbb_;
6101   flatbuffers::uoffset_t start_;
6102   explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6103   {
6104     start_ = fbb_.StartTable();
6105   }
6106   flatbuffers::Offset<GreaterEqualOptions> Finish()
6107   {
6108     const auto end = fbb_.EndTable(start_);
6109     auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
6110     return o;
6111   }
6112 };
6113
6114 inline flatbuffers::Offset<GreaterEqualOptions>
6115 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6116 {
6117   GreaterEqualOptionsBuilder builder_(_fbb);
6118   return builder_.Finish();
6119 }
6120
6121 struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6122 {
6123   typedef LessOptionsBuilder Builder;
6124   bool Verify(flatbuffers::Verifier &verifier) const
6125   {
6126     return VerifyTableStart(verifier) && verifier.EndTable();
6127   }
6128 };
6129
6130 struct LessOptionsBuilder
6131 {
6132   typedef LessOptions Table;
6133   flatbuffers::FlatBufferBuilder &fbb_;
6134   flatbuffers::uoffset_t start_;
6135   explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6136   {
6137     start_ = fbb_.StartTable();
6138   }
6139   flatbuffers::Offset<LessOptions> Finish()
6140   {
6141     const auto end = fbb_.EndTable(start_);
6142     auto o = flatbuffers::Offset<LessOptions>(end);
6143     return o;
6144   }
6145 };
6146
6147 inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb)
6148 {
6149   LessOptionsBuilder builder_(_fbb);
6150   return builder_.Finish();
6151 }
6152
6153 struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6154 {
6155   typedef LessEqualOptionsBuilder Builder;
6156   bool Verify(flatbuffers::Verifier &verifier) const
6157   {
6158     return VerifyTableStart(verifier) && verifier.EndTable();
6159   }
6160 };
6161
6162 struct LessEqualOptionsBuilder
6163 {
6164   typedef LessEqualOptions Table;
6165   flatbuffers::FlatBufferBuilder &fbb_;
6166   flatbuffers::uoffset_t start_;
6167   explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6168   {
6169     start_ = fbb_.StartTable();
6170   }
6171   flatbuffers::Offset<LessEqualOptions> Finish()
6172   {
6173     const auto end = fbb_.EndTable(start_);
6174     auto o = flatbuffers::Offset<LessEqualOptions>(end);
6175     return o;
6176   }
6177 };
6178
6179 inline flatbuffers::Offset<LessEqualOptions>
6180 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6181 {
6182   LessEqualOptionsBuilder builder_(_fbb);
6183   return builder_.Finish();
6184 }
6185
6186 struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6187 {
6188   typedef NegOptionsBuilder Builder;
6189   bool Verify(flatbuffers::Verifier &verifier) const
6190   {
6191     return VerifyTableStart(verifier) && verifier.EndTable();
6192   }
6193 };
6194
6195 struct NegOptionsBuilder
6196 {
6197   typedef NegOptions Table;
6198   flatbuffers::FlatBufferBuilder &fbb_;
6199   flatbuffers::uoffset_t start_;
6200   explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6201   {
6202     start_ = fbb_.StartTable();
6203   }
6204   flatbuffers::Offset<NegOptions> Finish()
6205   {
6206     const auto end = fbb_.EndTable(start_);
6207     auto o = flatbuffers::Offset<NegOptions>(end);
6208     return o;
6209   }
6210 };
6211
6212 inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb)
6213 {
6214   NegOptionsBuilder builder_(_fbb);
6215   return builder_.Finish();
6216 }
6217
6218 struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6219 {
6220   typedef SelectOptionsBuilder Builder;
6221   bool Verify(flatbuffers::Verifier &verifier) const
6222   {
6223     return VerifyTableStart(verifier) && verifier.EndTable();
6224   }
6225 };
6226
6227 struct SelectOptionsBuilder
6228 {
6229   typedef SelectOptions Table;
6230   flatbuffers::FlatBufferBuilder &fbb_;
6231   flatbuffers::uoffset_t start_;
6232   explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6233   {
6234     start_ = fbb_.StartTable();
6235   }
6236   flatbuffers::Offset<SelectOptions> Finish()
6237   {
6238     const auto end = fbb_.EndTable(start_);
6239     auto o = flatbuffers::Offset<SelectOptions>(end);
6240     return o;
6241   }
6242 };
6243
6244 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb)
6245 {
6246   SelectOptionsBuilder builder_(_fbb);
6247   return builder_.Finish();
6248 }
6249
6250 struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6251 {
6252   typedef SliceOptionsBuilder Builder;
6253   bool Verify(flatbuffers::Verifier &verifier) const
6254   {
6255     return VerifyTableStart(verifier) && verifier.EndTable();
6256   }
6257 };
6258
6259 struct SliceOptionsBuilder
6260 {
6261   typedef SliceOptions Table;
6262   flatbuffers::FlatBufferBuilder &fbb_;
6263   flatbuffers::uoffset_t start_;
6264   explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6265   {
6266     start_ = fbb_.StartTable();
6267   }
6268   flatbuffers::Offset<SliceOptions> Finish()
6269   {
6270     const auto end = fbb_.EndTable(start_);
6271     auto o = flatbuffers::Offset<SliceOptions>(end);
6272     return o;
6273   }
6274 };
6275
6276 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
6277 {
6278   SliceOptionsBuilder builder_(_fbb);
6279   return builder_.Finish();
6280 }
6281
6282 struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6283 {
6284   typedef TransposeConvOptionsBuilder Builder;
6285   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6286   {
6287     VT_PADDING = 4,
6288     VT_STRIDE_W = 6,
6289     VT_STRIDE_H = 8
6290   };
6291   onert_tflite::Padding padding() const
6292   {
6293     return static_cast<onert_tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
6294   }
6295   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
6296   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
6297   bool Verify(flatbuffers::Verifier &verifier) const
6298   {
6299     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
6300            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
6301            VerifyField<int32_t>(verifier, VT_STRIDE_H) && verifier.EndTable();
6302   }
6303 };
6304
6305 struct TransposeConvOptionsBuilder
6306 {
6307   typedef TransposeConvOptions Table;
6308   flatbuffers::FlatBufferBuilder &fbb_;
6309   flatbuffers::uoffset_t start_;
6310   void add_padding(onert_tflite::Padding padding)
6311   {
6312     fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
6313   }
6314   void add_stride_w(int32_t stride_w)
6315   {
6316     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
6317   }
6318   void add_stride_h(int32_t stride_h)
6319   {
6320     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
6321   }
6322   explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6323   {
6324     start_ = fbb_.StartTable();
6325   }
6326   flatbuffers::Offset<TransposeConvOptions> Finish()
6327   {
6328     const auto end = fbb_.EndTable(start_);
6329     auto o = flatbuffers::Offset<TransposeConvOptions>(end);
6330     return o;
6331   }
6332 };
6333
6334 inline flatbuffers::Offset<TransposeConvOptions>
6335 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb,
6336                            onert_tflite::Padding padding = onert_tflite::Padding_SAME,
6337                            int32_t stride_w = 0, int32_t stride_h = 0)
6338 {
6339   TransposeConvOptionsBuilder builder_(_fbb);
6340   builder_.add_stride_h(stride_h);
6341   builder_.add_stride_w(stride_w);
6342   builder_.add_padding(padding);
6343   return builder_.Finish();
6344 }
6345
6346 struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6347 {
6348   typedef ExpandDimsOptionsBuilder Builder;
6349   bool Verify(flatbuffers::Verifier &verifier) const
6350   {
6351     return VerifyTableStart(verifier) && verifier.EndTable();
6352   }
6353 };
6354
6355 struct ExpandDimsOptionsBuilder
6356 {
6357   typedef ExpandDimsOptions Table;
6358   flatbuffers::FlatBufferBuilder &fbb_;
6359   flatbuffers::uoffset_t start_;
6360   explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6361   {
6362     start_ = fbb_.StartTable();
6363   }
6364   flatbuffers::Offset<ExpandDimsOptions> Finish()
6365   {
6366     const auto end = fbb_.EndTable(start_);
6367     auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
6368     return o;
6369   }
6370 };
6371
6372 inline flatbuffers::Offset<ExpandDimsOptions>
6373 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb)
6374 {
6375   ExpandDimsOptionsBuilder builder_(_fbb);
6376   return builder_.Finish();
6377 }
6378
6379 struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6380 {
6381   typedef SparseToDenseOptionsBuilder Builder;
6382   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6383   {
6384     VT_VALIDATE_INDICES = 4
6385   };
6386   bool validate_indices() const { return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0; }
6387   bool Verify(flatbuffers::Verifier &verifier) const
6388   {
6389     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
6390            verifier.EndTable();
6391   }
6392 };
6393
6394 struct SparseToDenseOptionsBuilder
6395 {
6396   typedef SparseToDenseOptions Table;
6397   flatbuffers::FlatBufferBuilder &fbb_;
6398   flatbuffers::uoffset_t start_;
6399   void add_validate_indices(bool validate_indices)
6400   {
6401     fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES,
6402                              static_cast<uint8_t>(validate_indices), 0);
6403   }
6404   explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6405   {
6406     start_ = fbb_.StartTable();
6407   }
6408   flatbuffers::Offset<SparseToDenseOptions> Finish()
6409   {
6410     const auto end = fbb_.EndTable(start_);
6411     auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
6412     return o;
6413   }
6414 };
6415
6416 inline flatbuffers::Offset<SparseToDenseOptions>
6417 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices = false)
6418 {
6419   SparseToDenseOptionsBuilder builder_(_fbb);
6420   builder_.add_validate_indices(validate_indices);
6421   return builder_.Finish();
6422 }
6423
6424 struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6425 {
6426   typedef EqualOptionsBuilder Builder;
6427   bool Verify(flatbuffers::Verifier &verifier) const
6428   {
6429     return VerifyTableStart(verifier) && verifier.EndTable();
6430   }
6431 };
6432
6433 struct EqualOptionsBuilder
6434 {
6435   typedef EqualOptions Table;
6436   flatbuffers::FlatBufferBuilder &fbb_;
6437   flatbuffers::uoffset_t start_;
6438   explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6439   {
6440     start_ = fbb_.StartTable();
6441   }
6442   flatbuffers::Offset<EqualOptions> Finish()
6443   {
6444     const auto end = fbb_.EndTable(start_);
6445     auto o = flatbuffers::Offset<EqualOptions>(end);
6446     return o;
6447   }
6448 };
6449
6450 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6451 {
6452   EqualOptionsBuilder builder_(_fbb);
6453   return builder_.Finish();
6454 }
6455
6456 struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6457 {
6458   typedef NotEqualOptionsBuilder Builder;
6459   bool Verify(flatbuffers::Verifier &verifier) const
6460   {
6461     return VerifyTableStart(verifier) && verifier.EndTable();
6462   }
6463 };
6464
6465 struct NotEqualOptionsBuilder
6466 {
6467   typedef NotEqualOptions Table;
6468   flatbuffers::FlatBufferBuilder &fbb_;
6469   flatbuffers::uoffset_t start_;
6470   explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6471   {
6472     start_ = fbb_.StartTable();
6473   }
6474   flatbuffers::Offset<NotEqualOptions> Finish()
6475   {
6476     const auto end = fbb_.EndTable(start_);
6477     auto o = flatbuffers::Offset<NotEqualOptions>(end);
6478     return o;
6479   }
6480 };
6481
6482 inline flatbuffers::Offset<NotEqualOptions>
6483 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6484 {
6485   NotEqualOptionsBuilder builder_(_fbb);
6486   return builder_.Finish();
6487 }
6488
6489 struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6490 {
6491   typedef ShapeOptionsBuilder Builder;
6492   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6493   {
6494     VT_OUT_TYPE = 4
6495   };
6496   onert_tflite::TensorType out_type() const
6497   {
6498     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
6499   }
6500   bool Verify(flatbuffers::Verifier &verifier) const
6501   {
6502     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
6503            verifier.EndTable();
6504   }
6505 };
6506
6507 struct ShapeOptionsBuilder
6508 {
6509   typedef ShapeOptions Table;
6510   flatbuffers::FlatBufferBuilder &fbb_;
6511   flatbuffers::uoffset_t start_;
6512   void add_out_type(onert_tflite::TensorType out_type)
6513   {
6514     fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
6515   }
6516   explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6517   {
6518     start_ = fbb_.StartTable();
6519   }
6520   flatbuffers::Offset<ShapeOptions> Finish()
6521   {
6522     const auto end = fbb_.EndTable(start_);
6523     auto o = flatbuffers::Offset<ShapeOptions>(end);
6524     return o;
6525   }
6526 };
6527
6528 inline flatbuffers::Offset<ShapeOptions>
6529 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
6530                    onert_tflite::TensorType out_type = onert_tflite::TensorType_FLOAT32)
6531 {
6532   ShapeOptionsBuilder builder_(_fbb);
6533   builder_.add_out_type(out_type);
6534   return builder_.Finish();
6535 }
6536
6537 struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6538 {
6539   typedef RankOptionsBuilder Builder;
6540   bool Verify(flatbuffers::Verifier &verifier) const
6541   {
6542     return VerifyTableStart(verifier) && verifier.EndTable();
6543   }
6544 };
6545
6546 struct RankOptionsBuilder
6547 {
6548   typedef RankOptions Table;
6549   flatbuffers::FlatBufferBuilder &fbb_;
6550   flatbuffers::uoffset_t start_;
6551   explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6552   {
6553     start_ = fbb_.StartTable();
6554   }
6555   flatbuffers::Offset<RankOptions> Finish()
6556   {
6557     const auto end = fbb_.EndTable(start_);
6558     auto o = flatbuffers::Offset<RankOptions>(end);
6559     return o;
6560   }
6561 };
6562
6563 inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb)
6564 {
6565   RankOptionsBuilder builder_(_fbb);
6566   return builder_.Finish();
6567 }
6568
6569 struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6570 {
6571   typedef PowOptionsBuilder Builder;
6572   bool Verify(flatbuffers::Verifier &verifier) const
6573   {
6574     return VerifyTableStart(verifier) && verifier.EndTable();
6575   }
6576 };
6577
6578 struct PowOptionsBuilder
6579 {
6580   typedef PowOptions Table;
6581   flatbuffers::FlatBufferBuilder &fbb_;
6582   flatbuffers::uoffset_t start_;
6583   explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6584   {
6585     start_ = fbb_.StartTable();
6586   }
6587   flatbuffers::Offset<PowOptions> Finish()
6588   {
6589     const auto end = fbb_.EndTable(start_);
6590     auto o = flatbuffers::Offset<PowOptions>(end);
6591     return o;
6592   }
6593 };
6594
6595 inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb)
6596 {
6597   PowOptionsBuilder builder_(_fbb);
6598   return builder_.Finish();
6599 }
6600
6601 struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6602 {
6603   typedef FakeQuantOptionsBuilder Builder;
6604   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6605   {
6606     VT_MIN = 4,
6607     VT_MAX = 6,
6608     VT_NUM_BITS = 8,
6609     VT_NARROW_RANGE = 10
6610   };
6611   float min() const { return GetField<float>(VT_MIN, 0.0f); }
6612   float max() const { return GetField<float>(VT_MAX, 0.0f); }
6613   int32_t num_bits() const { return GetField<int32_t>(VT_NUM_BITS, 0); }
6614   bool narrow_range() const { return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0; }
6615   bool Verify(flatbuffers::Verifier &verifier) const
6616   {
6617     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_MIN) &&
6618            VerifyField<float>(verifier, VT_MAX) && VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
6619            VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) && verifier.EndTable();
6620   }
6621 };
6622
6623 struct FakeQuantOptionsBuilder
6624 {
6625   typedef FakeQuantOptions Table;
6626   flatbuffers::FlatBufferBuilder &fbb_;
6627   flatbuffers::uoffset_t start_;
6628   void add_min(float min) { fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f); }
6629   void add_max(float max) { fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f); }
6630   void add_num_bits(int32_t num_bits)
6631   {
6632     fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
6633   }
6634   void add_narrow_range(bool narrow_range)
6635   {
6636     fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range),
6637                              0);
6638   }
6639   explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6640   {
6641     start_ = fbb_.StartTable();
6642   }
6643   flatbuffers::Offset<FakeQuantOptions> Finish()
6644   {
6645     const auto end = fbb_.EndTable(start_);
6646     auto o = flatbuffers::Offset<FakeQuantOptions>(end);
6647     return o;
6648   }
6649 };
6650
6651 inline flatbuffers::Offset<FakeQuantOptions>
6652 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, float min = 0.0f, float max = 0.0f,
6653                        int32_t num_bits = 0, bool narrow_range = false)
6654 {
6655   FakeQuantOptionsBuilder builder_(_fbb);
6656   builder_.add_num_bits(num_bits);
6657   builder_.add_max(max);
6658   builder_.add_min(min);
6659   builder_.add_narrow_range(narrow_range);
6660   return builder_.Finish();
6661 }
6662
6663 struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6664 {
6665   typedef PackOptionsBuilder Builder;
6666   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6667   {
6668     VT_VALUES_COUNT = 4,
6669     VT_AXIS = 6
6670   };
6671   int32_t values_count() const { return GetField<int32_t>(VT_VALUES_COUNT, 0); }
6672   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6673   bool Verify(flatbuffers::Verifier &verifier) const
6674   {
6675     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
6676            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
6677   }
6678 };
6679
6680 struct PackOptionsBuilder
6681 {
6682   typedef PackOptions Table;
6683   flatbuffers::FlatBufferBuilder &fbb_;
6684   flatbuffers::uoffset_t start_;
6685   void add_values_count(int32_t values_count)
6686   {
6687     fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
6688   }
6689   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0); }
6690   explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6691   {
6692     start_ = fbb_.StartTable();
6693   }
6694   flatbuffers::Offset<PackOptions> Finish()
6695   {
6696     const auto end = fbb_.EndTable(start_);
6697     auto o = flatbuffers::Offset<PackOptions>(end);
6698     return o;
6699   }
6700 };
6701
6702 inline flatbuffers::Offset<PackOptions>
6703 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count = 0, int32_t axis = 0)
6704 {
6705   PackOptionsBuilder builder_(_fbb);
6706   builder_.add_axis(axis);
6707   builder_.add_values_count(values_count);
6708   return builder_.Finish();
6709 }
6710
6711 struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6712 {
6713   typedef LogicalOrOptionsBuilder Builder;
6714   bool Verify(flatbuffers::Verifier &verifier) const
6715   {
6716     return VerifyTableStart(verifier) && verifier.EndTable();
6717   }
6718 };
6719
6720 struct LogicalOrOptionsBuilder
6721 {
6722   typedef LogicalOrOptions Table;
6723   flatbuffers::FlatBufferBuilder &fbb_;
6724   flatbuffers::uoffset_t start_;
6725   explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6726   {
6727     start_ = fbb_.StartTable();
6728   }
6729   flatbuffers::Offset<LogicalOrOptions> Finish()
6730   {
6731     const auto end = fbb_.EndTable(start_);
6732     auto o = flatbuffers::Offset<LogicalOrOptions>(end);
6733     return o;
6734   }
6735 };
6736
6737 inline flatbuffers::Offset<LogicalOrOptions>
6738 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb)
6739 {
6740   LogicalOrOptionsBuilder builder_(_fbb);
6741   return builder_.Finish();
6742 }
6743
6744 struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6745 {
6746   typedef OneHotOptionsBuilder Builder;
6747   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6748   {
6749     VT_AXIS = 4
6750   };
6751   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6752   bool Verify(flatbuffers::Verifier &verifier) const
6753   {
6754     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
6755            verifier.EndTable();
6756   }
6757 };
6758
6759 struct OneHotOptionsBuilder
6760 {
6761   typedef OneHotOptions Table;
6762   flatbuffers::FlatBufferBuilder &fbb_;
6763   flatbuffers::uoffset_t start_;
6764   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0); }
6765   explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6766   {
6767     start_ = fbb_.StartTable();
6768   }
6769   flatbuffers::Offset<OneHotOptions> Finish()
6770   {
6771     const auto end = fbb_.EndTable(start_);
6772     auto o = flatbuffers::Offset<OneHotOptions>(end);
6773     return o;
6774   }
6775 };
6776
6777 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb,
6778                                                               int32_t axis = 0)
6779 {
6780   OneHotOptionsBuilder builder_(_fbb);
6781   builder_.add_axis(axis);
6782   return builder_.Finish();
6783 }
6784
6785 struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6786 {
6787   typedef AbsOptionsBuilder Builder;
6788   bool Verify(flatbuffers::Verifier &verifier) const
6789   {
6790     return VerifyTableStart(verifier) && verifier.EndTable();
6791   }
6792 };
6793
6794 struct AbsOptionsBuilder
6795 {
6796   typedef AbsOptions Table;
6797   flatbuffers::FlatBufferBuilder &fbb_;
6798   flatbuffers::uoffset_t start_;
6799   explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6800   {
6801     start_ = fbb_.StartTable();
6802   }
6803   flatbuffers::Offset<AbsOptions> Finish()
6804   {
6805     const auto end = fbb_.EndTable(start_);
6806     auto o = flatbuffers::Offset<AbsOptions>(end);
6807     return o;
6808   }
6809 };
6810
6811 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb)
6812 {
6813   AbsOptionsBuilder builder_(_fbb);
6814   return builder_.Finish();
6815 }
6816
6817 struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6818 {
6819   typedef HardSwishOptionsBuilder Builder;
6820   bool Verify(flatbuffers::Verifier &verifier) const
6821   {
6822     return VerifyTableStart(verifier) && verifier.EndTable();
6823   }
6824 };
6825
6826 struct HardSwishOptionsBuilder
6827 {
6828   typedef HardSwishOptions Table;
6829   flatbuffers::FlatBufferBuilder &fbb_;
6830   flatbuffers::uoffset_t start_;
6831   explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6832   {
6833     start_ = fbb_.StartTable();
6834   }
6835   flatbuffers::Offset<HardSwishOptions> Finish()
6836   {
6837     const auto end = fbb_.EndTable(start_);
6838     auto o = flatbuffers::Offset<HardSwishOptions>(end);
6839     return o;
6840   }
6841 };
6842
6843 inline flatbuffers::Offset<HardSwishOptions>
6844 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb)
6845 {
6846   HardSwishOptionsBuilder builder_(_fbb);
6847   return builder_.Finish();
6848 }
6849
6850 struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6851 {
6852   typedef LogicalAndOptionsBuilder Builder;
6853   bool Verify(flatbuffers::Verifier &verifier) const
6854   {
6855     return VerifyTableStart(verifier) && verifier.EndTable();
6856   }
6857 };
6858
6859 struct LogicalAndOptionsBuilder
6860 {
6861   typedef LogicalAndOptions Table;
6862   flatbuffers::FlatBufferBuilder &fbb_;
6863   flatbuffers::uoffset_t start_;
6864   explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6865   {
6866     start_ = fbb_.StartTable();
6867   }
6868   flatbuffers::Offset<LogicalAndOptions> Finish()
6869   {
6870     const auto end = fbb_.EndTable(start_);
6871     auto o = flatbuffers::Offset<LogicalAndOptions>(end);
6872     return o;
6873   }
6874 };
6875
6876 inline flatbuffers::Offset<LogicalAndOptions>
6877 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb)
6878 {
6879   LogicalAndOptionsBuilder builder_(_fbb);
6880   return builder_.Finish();
6881 }
6882
6883 struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6884 {
6885   typedef LogicalNotOptionsBuilder Builder;
6886   bool Verify(flatbuffers::Verifier &verifier) const
6887   {
6888     return VerifyTableStart(verifier) && verifier.EndTable();
6889   }
6890 };
6891
6892 struct LogicalNotOptionsBuilder
6893 {
6894   typedef LogicalNotOptions Table;
6895   flatbuffers::FlatBufferBuilder &fbb_;
6896   flatbuffers::uoffset_t start_;
6897   explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6898   {
6899     start_ = fbb_.StartTable();
6900   }
6901   flatbuffers::Offset<LogicalNotOptions> Finish()
6902   {
6903     const auto end = fbb_.EndTable(start_);
6904     auto o = flatbuffers::Offset<LogicalNotOptions>(end);
6905     return o;
6906   }
6907 };
6908
6909 inline flatbuffers::Offset<LogicalNotOptions>
6910 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb)
6911 {
6912   LogicalNotOptionsBuilder builder_(_fbb);
6913   return builder_.Finish();
6914 }
6915
6916 struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6917 {
6918   typedef UnpackOptionsBuilder Builder;
6919   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6920   {
6921     VT_NUM = 4,
6922     VT_AXIS = 6
6923   };
6924   int32_t num() const { return GetField<int32_t>(VT_NUM, 0); }
6925   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6926   bool Verify(flatbuffers::Verifier &verifier) const
6927   {
6928     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM) &&
6929            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
6930   }
6931 };
6932
6933 struct UnpackOptionsBuilder
6934 {
6935   typedef UnpackOptions Table;
6936   flatbuffers::FlatBufferBuilder &fbb_;
6937   flatbuffers::uoffset_t start_;
6938   void add_num(int32_t num) { fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0); }
6939   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0); }
6940   explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6941   {
6942     start_ = fbb_.StartTable();
6943   }
6944   flatbuffers::Offset<UnpackOptions> Finish()
6945   {
6946     const auto end = fbb_.EndTable(start_);
6947     auto o = flatbuffers::Offset<UnpackOptions>(end);
6948     return o;
6949   }
6950 };
6951
6952 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb,
6953                                                               int32_t num = 0, int32_t axis = 0)
6954 {
6955   UnpackOptionsBuilder builder_(_fbb);
6956   builder_.add_axis(axis);
6957   builder_.add_num(num);
6958   return builder_.Finish();
6959 }
6960
6961 struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6962 {
6963   typedef FloorDivOptionsBuilder Builder;
6964   bool Verify(flatbuffers::Verifier &verifier) const
6965   {
6966     return VerifyTableStart(verifier) && verifier.EndTable();
6967   }
6968 };
6969
6970 struct FloorDivOptionsBuilder
6971 {
6972   typedef FloorDivOptions Table;
6973   flatbuffers::FlatBufferBuilder &fbb_;
6974   flatbuffers::uoffset_t start_;
6975   explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6976   {
6977     start_ = fbb_.StartTable();
6978   }
6979   flatbuffers::Offset<FloorDivOptions> Finish()
6980   {
6981     const auto end = fbb_.EndTable(start_);
6982     auto o = flatbuffers::Offset<FloorDivOptions>(end);
6983     return o;
6984   }
6985 };
6986
6987 inline flatbuffers::Offset<FloorDivOptions>
6988 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb)
6989 {
6990   FloorDivOptionsBuilder builder_(_fbb);
6991   return builder_.Finish();
6992 }
6993
6994 struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6995 {
6996   typedef SquareOptionsBuilder Builder;
6997   bool Verify(flatbuffers::Verifier &verifier) const
6998   {
6999     return VerifyTableStart(verifier) && verifier.EndTable();
7000   }
7001 };
7002
7003 struct SquareOptionsBuilder
7004 {
7005   typedef SquareOptions Table;
7006   flatbuffers::FlatBufferBuilder &fbb_;
7007   flatbuffers::uoffset_t start_;
7008   explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7009   {
7010     start_ = fbb_.StartTable();
7011   }
7012   flatbuffers::Offset<SquareOptions> Finish()
7013   {
7014     const auto end = fbb_.EndTable(start_);
7015     auto o = flatbuffers::Offset<SquareOptions>(end);
7016     return o;
7017   }
7018 };
7019
7020 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb)
7021 {
7022   SquareOptionsBuilder builder_(_fbb);
7023   return builder_.Finish();
7024 }
7025
7026 struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7027 {
7028   typedef ZerosLikeOptionsBuilder Builder;
7029   bool Verify(flatbuffers::Verifier &verifier) const
7030   {
7031     return VerifyTableStart(verifier) && verifier.EndTable();
7032   }
7033 };
7034
7035 struct ZerosLikeOptionsBuilder
7036 {
7037   typedef ZerosLikeOptions Table;
7038   flatbuffers::FlatBufferBuilder &fbb_;
7039   flatbuffers::uoffset_t start_;
7040   explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7041   {
7042     start_ = fbb_.StartTable();
7043   }
7044   flatbuffers::Offset<ZerosLikeOptions> Finish()
7045   {
7046     const auto end = fbb_.EndTable(start_);
7047     auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
7048     return o;
7049   }
7050 };
7051
7052 inline flatbuffers::Offset<ZerosLikeOptions>
7053 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb)
7054 {
7055   ZerosLikeOptionsBuilder builder_(_fbb);
7056   return builder_.Finish();
7057 }
7058
7059 struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7060 {
7061   typedef FillOptionsBuilder Builder;
7062   bool Verify(flatbuffers::Verifier &verifier) const
7063   {
7064     return VerifyTableStart(verifier) && verifier.EndTable();
7065   }
7066 };
7067
7068 struct FillOptionsBuilder
7069 {
7070   typedef FillOptions Table;
7071   flatbuffers::FlatBufferBuilder &fbb_;
7072   flatbuffers::uoffset_t start_;
7073   explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7074   {
7075     start_ = fbb_.StartTable();
7076   }
7077   flatbuffers::Offset<FillOptions> Finish()
7078   {
7079     const auto end = fbb_.EndTable(start_);
7080     auto o = flatbuffers::Offset<FillOptions>(end);
7081     return o;
7082   }
7083 };
7084
7085 inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb)
7086 {
7087   FillOptionsBuilder builder_(_fbb);
7088   return builder_.Finish();
7089 }
7090
7091 struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7092 {
7093   typedef FloorModOptionsBuilder Builder;
7094   bool Verify(flatbuffers::Verifier &verifier) const
7095   {
7096     return VerifyTableStart(verifier) && verifier.EndTable();
7097   }
7098 };
7099
7100 struct FloorModOptionsBuilder
7101 {
7102   typedef FloorModOptions Table;
7103   flatbuffers::FlatBufferBuilder &fbb_;
7104   flatbuffers::uoffset_t start_;
7105   explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7106   {
7107     start_ = fbb_.StartTable();
7108   }
7109   flatbuffers::Offset<FloorModOptions> Finish()
7110   {
7111     const auto end = fbb_.EndTable(start_);
7112     auto o = flatbuffers::Offset<FloorModOptions>(end);
7113     return o;
7114   }
7115 };
7116
7117 inline flatbuffers::Offset<FloorModOptions>
7118 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb)
7119 {
7120   FloorModOptionsBuilder builder_(_fbb);
7121   return builder_.Finish();
7122 }
7123
7124 struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7125 {
7126   typedef RangeOptionsBuilder Builder;
7127   bool Verify(flatbuffers::Verifier &verifier) const
7128   {
7129     return VerifyTableStart(verifier) && verifier.EndTable();
7130   }
7131 };
7132
7133 struct RangeOptionsBuilder
7134 {
7135   typedef RangeOptions Table;
7136   flatbuffers::FlatBufferBuilder &fbb_;
7137   flatbuffers::uoffset_t start_;
7138   explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7139   {
7140     start_ = fbb_.StartTable();
7141   }
7142   flatbuffers::Offset<RangeOptions> Finish()
7143   {
7144     const auto end = fbb_.EndTable(start_);
7145     auto o = flatbuffers::Offset<RangeOptions>(end);
7146     return o;
7147   }
7148 };
7149
7150 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb)
7151 {
7152   RangeOptionsBuilder builder_(_fbb);
7153   return builder_.Finish();
7154 }
7155
7156 struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7157 {
7158   typedef LeakyReluOptionsBuilder Builder;
7159   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7160   {
7161     VT_ALPHA = 4
7162   };
7163   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
7164   bool Verify(flatbuffers::Verifier &verifier) const
7165   {
7166     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_ALPHA) &&
7167            verifier.EndTable();
7168   }
7169 };
7170
7171 struct LeakyReluOptionsBuilder
7172 {
7173   typedef LeakyReluOptions Table;
7174   flatbuffers::FlatBufferBuilder &fbb_;
7175   flatbuffers::uoffset_t start_;
7176   void add_alpha(float alpha) { fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); }
7177   explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7178   {
7179     start_ = fbb_.StartTable();
7180   }
7181   flatbuffers::Offset<LeakyReluOptions> Finish()
7182   {
7183     const auto end = fbb_.EndTable(start_);
7184     auto o = flatbuffers::Offset<LeakyReluOptions>(end);
7185     return o;
7186   }
7187 };
7188
7189 inline flatbuffers::Offset<LeakyReluOptions>
7190 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, float alpha = 0.0f)
7191 {
7192   LeakyReluOptionsBuilder builder_(_fbb);
7193   builder_.add_alpha(alpha);
7194   return builder_.Finish();
7195 }
7196
7197 struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7198 {
7199   typedef SquaredDifferenceOptionsBuilder Builder;
7200   bool Verify(flatbuffers::Verifier &verifier) const
7201   {
7202     return VerifyTableStart(verifier) && verifier.EndTable();
7203   }
7204 };
7205
7206 struct SquaredDifferenceOptionsBuilder
7207 {
7208   typedef SquaredDifferenceOptions Table;
7209   flatbuffers::FlatBufferBuilder &fbb_;
7210   flatbuffers::uoffset_t start_;
7211   explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7212   {
7213     start_ = fbb_.StartTable();
7214   }
7215   flatbuffers::Offset<SquaredDifferenceOptions> Finish()
7216   {
7217     const auto end = fbb_.EndTable(start_);
7218     auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
7219     return o;
7220   }
7221 };
7222
7223 inline flatbuffers::Offset<SquaredDifferenceOptions>
7224 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb)
7225 {
7226   SquaredDifferenceOptionsBuilder builder_(_fbb);
7227   return builder_.Finish();
7228 }
7229
7230 struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7231 {
7232   typedef MirrorPadOptionsBuilder Builder;
7233   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7234   {
7235     VT_MODE = 4
7236   };
7237   onert_tflite::MirrorPadMode mode() const
7238   {
7239     return static_cast<onert_tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
7240   }
7241   bool Verify(flatbuffers::Verifier &verifier) const
7242   {
7243     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_MODE) &&
7244            verifier.EndTable();
7245   }
7246 };
7247
7248 struct MirrorPadOptionsBuilder
7249 {
7250   typedef MirrorPadOptions Table;
7251   flatbuffers::FlatBufferBuilder &fbb_;
7252   flatbuffers::uoffset_t start_;
7253   void add_mode(onert_tflite::MirrorPadMode mode)
7254   {
7255     fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
7256   }
7257   explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7258   {
7259     start_ = fbb_.StartTable();
7260   }
7261   flatbuffers::Offset<MirrorPadOptions> Finish()
7262   {
7263     const auto end = fbb_.EndTable(start_);
7264     auto o = flatbuffers::Offset<MirrorPadOptions>(end);
7265     return o;
7266   }
7267 };
7268
7269 inline flatbuffers::Offset<MirrorPadOptions>
7270 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb,
7271                        onert_tflite::MirrorPadMode mode = onert_tflite::MirrorPadMode_REFLECT)
7272 {
7273   MirrorPadOptionsBuilder builder_(_fbb);
7274   builder_.add_mode(mode);
7275   return builder_.Finish();
7276 }
7277
7278 struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7279 {
7280   typedef UniqueOptionsBuilder Builder;
7281   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7282   {
7283     VT_IDX_OUT_TYPE = 4
7284   };
7285   onert_tflite::TensorType idx_out_type() const
7286   {
7287     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
7288   }
7289   bool Verify(flatbuffers::Verifier &verifier) const
7290   {
7291     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
7292            verifier.EndTable();
7293   }
7294 };
7295
7296 struct UniqueOptionsBuilder
7297 {
7298   typedef UniqueOptions Table;
7299   flatbuffers::FlatBufferBuilder &fbb_;
7300   flatbuffers::uoffset_t start_;
7301   void add_idx_out_type(onert_tflite::TensorType idx_out_type)
7302   {
7303     fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
7304   }
7305   explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7306   {
7307     start_ = fbb_.StartTable();
7308   }
7309   flatbuffers::Offset<UniqueOptions> Finish()
7310   {
7311     const auto end = fbb_.EndTable(start_);
7312     auto o = flatbuffers::Offset<UniqueOptions>(end);
7313     return o;
7314   }
7315 };
7316
7317 inline flatbuffers::Offset<UniqueOptions>
7318 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb,
7319                     onert_tflite::TensorType idx_out_type = onert_tflite::TensorType_INT32)
7320 {
7321   UniqueOptionsBuilder builder_(_fbb);
7322   builder_.add_idx_out_type(idx_out_type);
7323   return builder_.Finish();
7324 }
7325
7326 struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7327 {
7328   typedef ReverseV2OptionsBuilder Builder;
7329   bool Verify(flatbuffers::Verifier &verifier) const
7330   {
7331     return VerifyTableStart(verifier) && verifier.EndTable();
7332   }
7333 };
7334
7335 struct ReverseV2OptionsBuilder
7336 {
7337   typedef ReverseV2Options Table;
7338   flatbuffers::FlatBufferBuilder &fbb_;
7339   flatbuffers::uoffset_t start_;
7340   explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7341   {
7342     start_ = fbb_.StartTable();
7343   }
7344   flatbuffers::Offset<ReverseV2Options> Finish()
7345   {
7346     const auto end = fbb_.EndTable(start_);
7347     auto o = flatbuffers::Offset<ReverseV2Options>(end);
7348     return o;
7349   }
7350 };
7351
7352 inline flatbuffers::Offset<ReverseV2Options>
7353 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7354 {
7355   ReverseV2OptionsBuilder builder_(_fbb);
7356   return builder_.Finish();
7357 }
7358
7359 struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7360 {
7361   typedef AddNOptionsBuilder Builder;
7362   bool Verify(flatbuffers::Verifier &verifier) const
7363   {
7364     return VerifyTableStart(verifier) && verifier.EndTable();
7365   }
7366 };
7367
7368 struct AddNOptionsBuilder
7369 {
7370   typedef AddNOptions Table;
7371   flatbuffers::FlatBufferBuilder &fbb_;
7372   flatbuffers::uoffset_t start_;
7373   explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7374   {
7375     start_ = fbb_.StartTable();
7376   }
7377   flatbuffers::Offset<AddNOptions> Finish()
7378   {
7379     const auto end = fbb_.EndTable(start_);
7380     auto o = flatbuffers::Offset<AddNOptions>(end);
7381     return o;
7382   }
7383 };
7384
7385 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb)
7386 {
7387   AddNOptionsBuilder builder_(_fbb);
7388   return builder_.Finish();
7389 }
7390
7391 struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7392 {
7393   typedef GatherNdOptionsBuilder Builder;
7394   bool Verify(flatbuffers::Verifier &verifier) const
7395   {
7396     return VerifyTableStart(verifier) && verifier.EndTable();
7397   }
7398 };
7399
7400 struct GatherNdOptionsBuilder
7401 {
7402   typedef GatherNdOptions Table;
7403   flatbuffers::FlatBufferBuilder &fbb_;
7404   flatbuffers::uoffset_t start_;
7405   explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7406   {
7407     start_ = fbb_.StartTable();
7408   }
7409   flatbuffers::Offset<GatherNdOptions> Finish()
7410   {
7411     const auto end = fbb_.EndTable(start_);
7412     auto o = flatbuffers::Offset<GatherNdOptions>(end);
7413     return o;
7414   }
7415 };
7416
7417 inline flatbuffers::Offset<GatherNdOptions>
7418 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
7419 {
7420   GatherNdOptionsBuilder builder_(_fbb);
7421   return builder_.Finish();
7422 }
7423
7424 struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7425 {
7426   typedef WhereOptionsBuilder Builder;
7427   bool Verify(flatbuffers::Verifier &verifier) const
7428   {
7429     return VerifyTableStart(verifier) && verifier.EndTable();
7430   }
7431 };
7432
7433 struct WhereOptionsBuilder
7434 {
7435   typedef WhereOptions Table;
7436   flatbuffers::FlatBufferBuilder &fbb_;
7437   flatbuffers::uoffset_t start_;
7438   explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7439   {
7440     start_ = fbb_.StartTable();
7441   }
7442   flatbuffers::Offset<WhereOptions> Finish()
7443   {
7444     const auto end = fbb_.EndTable(start_);
7445     auto o = flatbuffers::Offset<WhereOptions>(end);
7446     return o;
7447   }
7448 };
7449
7450 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb)
7451 {
7452   WhereOptionsBuilder builder_(_fbb);
7453   return builder_.Finish();
7454 }
7455
7456 struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7457 {
7458   typedef ReverseSequenceOptionsBuilder Builder;
7459   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7460   {
7461     VT_SEQ_DIM = 4,
7462     VT_BATCH_DIM = 6
7463   };
7464   int32_t seq_dim() const { return GetField<int32_t>(VT_SEQ_DIM, 0); }
7465   int32_t batch_dim() const { return GetField<int32_t>(VT_BATCH_DIM, 0); }
7466   bool Verify(flatbuffers::Verifier &verifier) const
7467   {
7468     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
7469            VerifyField<int32_t>(verifier, VT_BATCH_DIM) && verifier.EndTable();
7470   }
7471 };
7472
7473 struct ReverseSequenceOptionsBuilder
7474 {
7475   typedef ReverseSequenceOptions Table;
7476   flatbuffers::FlatBufferBuilder &fbb_;
7477   flatbuffers::uoffset_t start_;
7478   void add_seq_dim(int32_t seq_dim)
7479   {
7480     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
7481   }
7482   void add_batch_dim(int32_t batch_dim)
7483   {
7484     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
7485   }
7486   explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7487   {
7488     start_ = fbb_.StartTable();
7489   }
7490   flatbuffers::Offset<ReverseSequenceOptions> Finish()
7491   {
7492     const auto end = fbb_.EndTable(start_);
7493     auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
7494     return o;
7495   }
7496 };
7497
7498 inline flatbuffers::Offset<ReverseSequenceOptions>
7499 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim = 0,
7500                              int32_t batch_dim = 0)
7501 {
7502   ReverseSequenceOptionsBuilder builder_(_fbb);
7503   builder_.add_batch_dim(batch_dim);
7504   builder_.add_seq_dim(seq_dim);
7505   return builder_.Finish();
7506 }
7507
7508 struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7509 {
7510   typedef MatrixDiagOptionsBuilder Builder;
7511   bool Verify(flatbuffers::Verifier &verifier) const
7512   {
7513     return VerifyTableStart(verifier) && verifier.EndTable();
7514   }
7515 };
7516
7517 struct MatrixDiagOptionsBuilder
7518 {
7519   typedef MatrixDiagOptions Table;
7520   flatbuffers::FlatBufferBuilder &fbb_;
7521   flatbuffers::uoffset_t start_;
7522   explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7523   {
7524     start_ = fbb_.StartTable();
7525   }
7526   flatbuffers::Offset<MatrixDiagOptions> Finish()
7527   {
7528     const auto end = fbb_.EndTable(start_);
7529     auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
7530     return o;
7531   }
7532 };
7533
7534 inline flatbuffers::Offset<MatrixDiagOptions>
7535 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
7536 {
7537   MatrixDiagOptionsBuilder builder_(_fbb);
7538   return builder_.Finish();
7539 }
7540
7541 struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7542 {
7543   typedef QuantizeOptionsBuilder Builder;
7544   bool Verify(flatbuffers::Verifier &verifier) const
7545   {
7546     return VerifyTableStart(verifier) && verifier.EndTable();
7547   }
7548 };
7549
7550 struct QuantizeOptionsBuilder
7551 {
7552   typedef QuantizeOptions Table;
7553   flatbuffers::FlatBufferBuilder &fbb_;
7554   flatbuffers::uoffset_t start_;
7555   explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7556   {
7557     start_ = fbb_.StartTable();
7558   }
7559   flatbuffers::Offset<QuantizeOptions> Finish()
7560   {
7561     const auto end = fbb_.EndTable(start_);
7562     auto o = flatbuffers::Offset<QuantizeOptions>(end);
7563     return o;
7564   }
7565 };
7566
7567 inline flatbuffers::Offset<QuantizeOptions>
7568 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
7569 {
7570   QuantizeOptionsBuilder builder_(_fbb);
7571   return builder_.Finish();
7572 }
7573
7574 struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7575 {
7576   typedef MatrixSetDiagOptionsBuilder Builder;
7577   bool Verify(flatbuffers::Verifier &verifier) const
7578   {
7579     return VerifyTableStart(verifier) && verifier.EndTable();
7580   }
7581 };
7582
7583 struct MatrixSetDiagOptionsBuilder
7584 {
7585   typedef MatrixSetDiagOptions Table;
7586   flatbuffers::FlatBufferBuilder &fbb_;
7587   flatbuffers::uoffset_t start_;
7588   explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7589   {
7590     start_ = fbb_.StartTable();
7591   }
7592   flatbuffers::Offset<MatrixSetDiagOptions> Finish()
7593   {
7594     const auto end = fbb_.EndTable(start_);
7595     auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
7596     return o;
7597   }
7598 };
7599
7600 inline flatbuffers::Offset<MatrixSetDiagOptions>
7601 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
7602 {
7603   MatrixSetDiagOptionsBuilder builder_(_fbb);
7604   return builder_.Finish();
7605 }
7606
7607 struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7608 {
7609   typedef IfOptionsBuilder Builder;
7610   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7611   {
7612     VT_THEN_SUBGRAPH_INDEX = 4,
7613     VT_ELSE_SUBGRAPH_INDEX = 6
7614   };
7615   int32_t then_subgraph_index() const { return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0); }
7616   int32_t else_subgraph_index() const { return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0); }
7617   bool Verify(flatbuffers::Verifier &verifier) const
7618   {
7619     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
7620            VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) && verifier.EndTable();
7621   }
7622 };
7623
7624 struct IfOptionsBuilder
7625 {
7626   typedef IfOptions Table;
7627   flatbuffers::FlatBufferBuilder &fbb_;
7628   flatbuffers::uoffset_t start_;
7629   void add_then_subgraph_index(int32_t then_subgraph_index)
7630   {
7631     fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
7632   }
7633   void add_else_subgraph_index(int32_t else_subgraph_index)
7634   {
7635     fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
7636   }
7637   explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7638   {
7639     start_ = fbb_.StartTable();
7640   }
7641   flatbuffers::Offset<IfOptions> Finish()
7642   {
7643     const auto end = fbb_.EndTable(start_);
7644     auto o = flatbuffers::Offset<IfOptions>(end);
7645     return o;
7646   }
7647 };
7648
7649 inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb,
7650                                                       int32_t then_subgraph_index = 0,
7651                                                       int32_t else_subgraph_index = 0)
7652 {
7653   IfOptionsBuilder builder_(_fbb);
7654   builder_.add_else_subgraph_index(else_subgraph_index);
7655   builder_.add_then_subgraph_index(then_subgraph_index);
7656   return builder_.Finish();
7657 }
7658
7659 struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7660 {
7661   typedef CallOnceOptionsBuilder Builder;
7662   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7663   {
7664     VT_INIT_SUBGRAPH_INDEX = 4
7665   };
7666   int32_t init_subgraph_index() const { return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0); }
7667   bool Verify(flatbuffers::Verifier &verifier) const
7668   {
7669     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX) &&
7670            verifier.EndTable();
7671   }
7672 };
7673
7674 struct CallOnceOptionsBuilder
7675 {
7676   typedef CallOnceOptions Table;
7677   flatbuffers::FlatBufferBuilder &fbb_;
7678   flatbuffers::uoffset_t start_;
7679   void add_init_subgraph_index(int32_t init_subgraph_index)
7680   {
7681     fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0);
7682   }
7683   explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7684   {
7685     start_ = fbb_.StartTable();
7686   }
7687   flatbuffers::Offset<CallOnceOptions> Finish()
7688   {
7689     const auto end = fbb_.EndTable(start_);
7690     auto o = flatbuffers::Offset<CallOnceOptions>(end);
7691     return o;
7692   }
7693 };
7694
7695 inline flatbuffers::Offset<CallOnceOptions>
7696 CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t init_subgraph_index = 0)
7697 {
7698   CallOnceOptionsBuilder builder_(_fbb);
7699   builder_.add_init_subgraph_index(init_subgraph_index);
7700   return builder_.Finish();
7701 }
7702
7703 struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7704 {
7705   typedef WhileOptionsBuilder Builder;
7706   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7707   {
7708     VT_COND_SUBGRAPH_INDEX = 4,
7709     VT_BODY_SUBGRAPH_INDEX = 6
7710   };
7711   int32_t cond_subgraph_index() const { return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0); }
7712   int32_t body_subgraph_index() const { return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0); }
7713   bool Verify(flatbuffers::Verifier &verifier) const
7714   {
7715     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
7716            VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) && verifier.EndTable();
7717   }
7718 };
7719
7720 struct WhileOptionsBuilder
7721 {
7722   typedef WhileOptions Table;
7723   flatbuffers::FlatBufferBuilder &fbb_;
7724   flatbuffers::uoffset_t start_;
7725   void add_cond_subgraph_index(int32_t cond_subgraph_index)
7726   {
7727     fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
7728   }
7729   void add_body_subgraph_index(int32_t body_subgraph_index)
7730   {
7731     fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
7732   }
7733   explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7734   {
7735     start_ = fbb_.StartTable();
7736   }
7737   flatbuffers::Offset<WhileOptions> Finish()
7738   {
7739     const auto end = fbb_.EndTable(start_);
7740     auto o = flatbuffers::Offset<WhileOptions>(end);
7741     return o;
7742   }
7743 };
7744
7745 inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb,
7746                                                             int32_t cond_subgraph_index = 0,
7747                                                             int32_t body_subgraph_index = 0)
7748 {
7749   WhileOptionsBuilder builder_(_fbb);
7750   builder_.add_body_subgraph_index(body_subgraph_index);
7751   builder_.add_cond_subgraph_index(cond_subgraph_index);
7752   return builder_.Finish();
7753 }
7754
7755 struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7756 {
7757   typedef NonMaxSuppressionV4OptionsBuilder Builder;
7758   bool Verify(flatbuffers::Verifier &verifier) const
7759   {
7760     return VerifyTableStart(verifier) && verifier.EndTable();
7761   }
7762 };
7763
7764 struct NonMaxSuppressionV4OptionsBuilder
7765 {
7766   typedef NonMaxSuppressionV4Options Table;
7767   flatbuffers::FlatBufferBuilder &fbb_;
7768   flatbuffers::uoffset_t start_;
7769   explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7770   {
7771     start_ = fbb_.StartTable();
7772   }
7773   flatbuffers::Offset<NonMaxSuppressionV4Options> Finish()
7774   {
7775     const auto end = fbb_.EndTable(start_);
7776     auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
7777     return o;
7778   }
7779 };
7780
7781 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
7782 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb)
7783 {
7784   NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
7785   return builder_.Finish();
7786 }
7787
7788 struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7789 {
7790   typedef NonMaxSuppressionV5OptionsBuilder Builder;
7791   bool Verify(flatbuffers::Verifier &verifier) const
7792   {
7793     return VerifyTableStart(verifier) && verifier.EndTable();
7794   }
7795 };
7796
7797 struct NonMaxSuppressionV5OptionsBuilder
7798 {
7799   typedef NonMaxSuppressionV5Options Table;
7800   flatbuffers::FlatBufferBuilder &fbb_;
7801   flatbuffers::uoffset_t start_;
7802   explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7803   {
7804     start_ = fbb_.StartTable();
7805   }
7806   flatbuffers::Offset<NonMaxSuppressionV5Options> Finish()
7807   {
7808     const auto end = fbb_.EndTable(start_);
7809     auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
7810     return o;
7811   }
7812 };
7813
7814 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
7815 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb)
7816 {
7817   NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
7818   return builder_.Finish();
7819 }
7820
7821 struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7822 {
7823   typedef ScatterNdOptionsBuilder Builder;
7824   bool Verify(flatbuffers::Verifier &verifier) const
7825   {
7826     return VerifyTableStart(verifier) && verifier.EndTable();
7827   }
7828 };
7829
7830 struct ScatterNdOptionsBuilder
7831 {
7832   typedef ScatterNdOptions Table;
7833   flatbuffers::FlatBufferBuilder &fbb_;
7834   flatbuffers::uoffset_t start_;
7835   explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7836   {
7837     start_ = fbb_.StartTable();
7838   }
7839   flatbuffers::Offset<ScatterNdOptions> Finish()
7840   {
7841     const auto end = fbb_.EndTable(start_);
7842     auto o = flatbuffers::Offset<ScatterNdOptions>(end);
7843     return o;
7844   }
7845 };
7846
7847 inline flatbuffers::Offset<ScatterNdOptions>
7848 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
7849 {
7850   ScatterNdOptionsBuilder builder_(_fbb);
7851   return builder_.Finish();
7852 }
7853
7854 struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7855 {
7856   typedef SelectV2OptionsBuilder Builder;
7857   bool Verify(flatbuffers::Verifier &verifier) const
7858   {
7859     return VerifyTableStart(verifier) && verifier.EndTable();
7860   }
7861 };
7862
7863 struct SelectV2OptionsBuilder
7864 {
7865   typedef SelectV2Options Table;
7866   flatbuffers::FlatBufferBuilder &fbb_;
7867   flatbuffers::uoffset_t start_;
7868   explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7869   {
7870     start_ = fbb_.StartTable();
7871   }
7872   flatbuffers::Offset<SelectV2Options> Finish()
7873   {
7874     const auto end = fbb_.EndTable(start_);
7875     auto o = flatbuffers::Offset<SelectV2Options>(end);
7876     return o;
7877   }
7878 };
7879
7880 inline flatbuffers::Offset<SelectV2Options>
7881 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7882 {
7883   SelectV2OptionsBuilder builder_(_fbb);
7884   return builder_.Finish();
7885 }
7886
7887 struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7888 {
7889   typedef DensifyOptionsBuilder Builder;
7890   bool Verify(flatbuffers::Verifier &verifier) const
7891   {
7892     return VerifyTableStart(verifier) && verifier.EndTable();
7893   }
7894 };
7895
7896 struct DensifyOptionsBuilder
7897 {
7898   typedef DensifyOptions Table;
7899   flatbuffers::FlatBufferBuilder &fbb_;
7900   flatbuffers::uoffset_t start_;
7901   explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7902   {
7903     start_ = fbb_.StartTable();
7904   }
7905   flatbuffers::Offset<DensifyOptions> Finish()
7906   {
7907     const auto end = fbb_.EndTable(start_);
7908     auto o = flatbuffers::Offset<DensifyOptions>(end);
7909     return o;
7910   }
7911 };
7912
7913 inline flatbuffers::Offset<DensifyOptions>
7914 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb)
7915 {
7916   DensifyOptionsBuilder builder_(_fbb);
7917   return builder_.Finish();
7918 }
7919
7920 struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7921 {
7922   typedef SegmentSumOptionsBuilder Builder;
7923   bool Verify(flatbuffers::Verifier &verifier) const
7924   {
7925     return VerifyTableStart(verifier) && verifier.EndTable();
7926   }
7927 };
7928
7929 struct SegmentSumOptionsBuilder
7930 {
7931   typedef SegmentSumOptions Table;
7932   flatbuffers::FlatBufferBuilder &fbb_;
7933   flatbuffers::uoffset_t start_;
7934   explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7935   {
7936     start_ = fbb_.StartTable();
7937   }
7938   flatbuffers::Offset<SegmentSumOptions> Finish()
7939   {
7940     const auto end = fbb_.EndTable(start_);
7941     auto o = flatbuffers::Offset<SegmentSumOptions>(end);
7942     return o;
7943   }
7944 };
7945
7946 inline flatbuffers::Offset<SegmentSumOptions>
7947 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
7948 {
7949   SegmentSumOptionsBuilder builder_(_fbb);
7950   return builder_.Finish();
7951 }
7952
7953 struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7954 {
7955   typedef BatchMatMulOptionsBuilder Builder;
7956   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7957   {
7958     VT_ADJ_X = 4,
7959     VT_ADJ_Y = 6,
7960     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
7961   };
7962   bool adj_x() const { return GetField<uint8_t>(VT_ADJ_X, 0) != 0; }
7963   bool adj_y() const { return GetField<uint8_t>(VT_ADJ_Y, 0) != 0; }
7964   bool asymmetric_quantize_inputs() const
7965   {
7966     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
7967   }
7968   bool Verify(flatbuffers::Verifier &verifier) const
7969   {
7970     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ADJ_X) &&
7971            VerifyField<uint8_t>(verifier, VT_ADJ_Y) &&
7972            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
7973   }
7974 };
7975
7976 struct BatchMatMulOptionsBuilder
7977 {
7978   typedef BatchMatMulOptions Table;
7979   flatbuffers::FlatBufferBuilder &fbb_;
7980   flatbuffers::uoffset_t start_;
7981   void add_adj_x(bool adj_x)
7982   {
7983     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), 0);
7984   }
7985   void add_adj_y(bool adj_y)
7986   {
7987     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), 0);
7988   }
7989   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
7990   {
7991     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
7992                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
7993   }
7994   explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7995   {
7996     start_ = fbb_.StartTable();
7997   }
7998   flatbuffers::Offset<BatchMatMulOptions> Finish()
7999   {
8000     const auto end = fbb_.EndTable(start_);
8001     auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
8002     return o;
8003   }
8004 };
8005
8006 inline flatbuffers::Offset<BatchMatMulOptions>
8007 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, bool adj_x = false,
8008                          bool adj_y = false, bool asymmetric_quantize_inputs = false)
8009 {
8010   BatchMatMulOptionsBuilder builder_(_fbb);
8011   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
8012   builder_.add_adj_y(adj_y);
8013   builder_.add_adj_x(adj_x);
8014   return builder_.Finish();
8015 }
8016
8017 struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8018 {
8019   typedef CumsumOptionsBuilder Builder;
8020   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8021   {
8022     VT_EXCLUSIVE = 4,
8023     VT_REVERSE = 6
8024   };
8025   bool exclusive() const { return GetField<uint8_t>(VT_EXCLUSIVE, 0) != 0; }
8026   bool reverse() const { return GetField<uint8_t>(VT_REVERSE, 0) != 0; }
8027   bool Verify(flatbuffers::Verifier &verifier) const
8028   {
8029     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_EXCLUSIVE) &&
8030            VerifyField<uint8_t>(verifier, VT_REVERSE) && verifier.EndTable();
8031   }
8032 };
8033
8034 struct CumsumOptionsBuilder
8035 {
8036   typedef CumsumOptions Table;
8037   flatbuffers::FlatBufferBuilder &fbb_;
8038   flatbuffers::uoffset_t start_;
8039   void add_exclusive(bool exclusive)
8040   {
8041     fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
8042   }
8043   void add_reverse(bool reverse)
8044   {
8045     fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
8046   }
8047   explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8048   {
8049     start_ = fbb_.StartTable();
8050   }
8051   flatbuffers::Offset<CumsumOptions> Finish()
8052   {
8053     const auto end = fbb_.EndTable(start_);
8054     auto o = flatbuffers::Offset<CumsumOptions>(end);
8055     return o;
8056   }
8057 };
8058
8059 inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb,
8060                                                               bool exclusive = false,
8061                                                               bool reverse = false)
8062 {
8063   CumsumOptionsBuilder builder_(_fbb);
8064   builder_.add_reverse(reverse);
8065   builder_.add_exclusive(exclusive);
8066   return builder_.Finish();
8067 }
8068
8069 struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8070 {
8071   typedef BroadcastToOptionsBuilder Builder;
8072   bool Verify(flatbuffers::Verifier &verifier) const
8073   {
8074     return VerifyTableStart(verifier) && verifier.EndTable();
8075   }
8076 };
8077
8078 struct BroadcastToOptionsBuilder
8079 {
8080   typedef BroadcastToOptions Table;
8081   flatbuffers::FlatBufferBuilder &fbb_;
8082   flatbuffers::uoffset_t start_;
8083   explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8084   {
8085     start_ = fbb_.StartTable();
8086   }
8087   flatbuffers::Offset<BroadcastToOptions> Finish()
8088   {
8089     const auto end = fbb_.EndTable(start_);
8090     auto o = flatbuffers::Offset<BroadcastToOptions>(end);
8091     return o;
8092   }
8093 };
8094
8095 inline flatbuffers::Offset<BroadcastToOptions>
8096 CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb)
8097 {
8098   BroadcastToOptionsBuilder builder_(_fbb);
8099   return builder_.Finish();
8100 }
8101
8102 struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8103 {
8104   typedef Rfft2dOptionsBuilder Builder;
8105   bool Verify(flatbuffers::Verifier &verifier) const
8106   {
8107     return VerifyTableStart(verifier) && verifier.EndTable();
8108   }
8109 };
8110
8111 struct Rfft2dOptionsBuilder
8112 {
8113   typedef Rfft2dOptions Table;
8114   flatbuffers::FlatBufferBuilder &fbb_;
8115   flatbuffers::uoffset_t start_;
8116   explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8117   {
8118     start_ = fbb_.StartTable();
8119   }
8120   flatbuffers::Offset<Rfft2dOptions> Finish()
8121   {
8122     const auto end = fbb_.EndTable(start_);
8123     auto o = flatbuffers::Offset<Rfft2dOptions>(end);
8124     return o;
8125   }
8126 };
8127
8128 inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb)
8129 {
8130   Rfft2dOptionsBuilder builder_(_fbb);
8131   return builder_.Finish();
8132 }
8133
8134 struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8135 {
8136   typedef HashtableOptionsBuilder Builder;
8137   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8138   {
8139     VT_TABLE_ID = 4,
8140     VT_KEY_DTYPE = 6,
8141     VT_VALUE_DTYPE = 8
8142   };
8143   int32_t table_id() const { return GetField<int32_t>(VT_TABLE_ID, 0); }
8144   onert_tflite::TensorType key_dtype() const
8145   {
8146     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, 0));
8147   }
8148   onert_tflite::TensorType value_dtype() const
8149   {
8150     return static_cast<onert_tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
8151   }
8152   bool Verify(flatbuffers::Verifier &verifier) const
8153   {
8154     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_TABLE_ID) &&
8155            VerifyField<int8_t>(verifier, VT_KEY_DTYPE) &&
8156            VerifyField<int8_t>(verifier, VT_VALUE_DTYPE) && verifier.EndTable();
8157   }
8158 };
8159
8160 struct HashtableOptionsBuilder
8161 {
8162   typedef HashtableOptions Table;
8163   flatbuffers::FlatBufferBuilder &fbb_;
8164   flatbuffers::uoffset_t start_;
8165   void add_table_id(int32_t table_id)
8166   {
8167     fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
8168   }
8169   void add_key_dtype(onert_tflite::TensorType key_dtype)
8170   {
8171     fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), 0);
8172   }
8173   void add_value_dtype(onert_tflite::TensorType value_dtype)
8174   {
8175     fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
8176   }
8177   explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8178   {
8179     start_ = fbb_.StartTable();
8180   }
8181   flatbuffers::Offset<HashtableOptions> Finish()
8182   {
8183     const auto end = fbb_.EndTable(start_);
8184     auto o = flatbuffers::Offset<HashtableOptions>(end);
8185     return o;
8186   }
8187 };
8188
8189 inline flatbuffers::Offset<HashtableOptions>
8190 CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t table_id = 0,
8191                        onert_tflite::TensorType key_dtype = onert_tflite::TensorType_FLOAT32,
8192                        onert_tflite::TensorType value_dtype = onert_tflite::TensorType_FLOAT32)
8193 {
8194   HashtableOptionsBuilder builder_(_fbb);
8195   builder_.add_table_id(table_id);
8196   builder_.add_value_dtype(value_dtype);
8197   builder_.add_key_dtype(key_dtype);
8198   return builder_.Finish();
8199 }
8200
8201 struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8202 {
8203   typedef HashtableFindOptionsBuilder Builder;
8204   bool Verify(flatbuffers::Verifier &verifier) const
8205   {
8206     return VerifyTableStart(verifier) && verifier.EndTable();
8207   }
8208 };
8209
8210 struct HashtableFindOptionsBuilder
8211 {
8212   typedef HashtableFindOptions Table;
8213   flatbuffers::FlatBufferBuilder &fbb_;
8214   flatbuffers::uoffset_t start_;
8215   explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8216   {
8217     start_ = fbb_.StartTable();
8218   }
8219   flatbuffers::Offset<HashtableFindOptions> Finish()
8220   {
8221     const auto end = fbb_.EndTable(start_);
8222     auto o = flatbuffers::Offset<HashtableFindOptions>(end);
8223     return o;
8224   }
8225 };
8226
8227 inline flatbuffers::Offset<HashtableFindOptions>
8228 CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb)
8229 {
8230   HashtableFindOptionsBuilder builder_(_fbb);
8231   return builder_.Finish();
8232 }
8233
8234 struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8235 {
8236   typedef HashtableImportOptionsBuilder Builder;
8237   bool Verify(flatbuffers::Verifier &verifier) const
8238   {
8239     return VerifyTableStart(verifier) && verifier.EndTable();
8240   }
8241 };
8242
8243 struct HashtableImportOptionsBuilder
8244 {
8245   typedef HashtableImportOptions Table;
8246   flatbuffers::FlatBufferBuilder &fbb_;
8247   flatbuffers::uoffset_t start_;
8248   explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8249   {
8250     start_ = fbb_.StartTable();
8251   }
8252   flatbuffers::Offset<HashtableImportOptions> Finish()
8253   {
8254     const auto end = fbb_.EndTable(start_);
8255     auto o = flatbuffers::Offset<HashtableImportOptions>(end);
8256     return o;
8257   }
8258 };
8259
8260 inline flatbuffers::Offset<HashtableImportOptions>
8261 CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb)
8262 {
8263   HashtableImportOptionsBuilder builder_(_fbb);
8264   return builder_.Finish();
8265 }
8266
8267 struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8268 {
8269   typedef HashtableSizeOptionsBuilder Builder;
8270   bool Verify(flatbuffers::Verifier &verifier) const
8271   {
8272     return VerifyTableStart(verifier) && verifier.EndTable();
8273   }
8274 };
8275
8276 struct HashtableSizeOptionsBuilder
8277 {
8278   typedef HashtableSizeOptions Table;
8279   flatbuffers::FlatBufferBuilder &fbb_;
8280   flatbuffers::uoffset_t start_;
8281   explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8282   {
8283     start_ = fbb_.StartTable();
8284   }
8285   flatbuffers::Offset<HashtableSizeOptions> Finish()
8286   {
8287     const auto end = fbb_.EndTable(start_);
8288     auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
8289     return o;
8290   }
8291 };
8292
8293 inline flatbuffers::Offset<HashtableSizeOptions>
8294 CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
8295 {
8296   HashtableSizeOptionsBuilder builder_(_fbb);
8297   return builder_.Finish();
8298 }
8299
8300 struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8301 {
8302   typedef VarHandleOptionsBuilder Builder;
8303   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8304   {
8305     VT_CONTAINER = 4,
8306     VT_SHARED_NAME = 6
8307   };
8308   const flatbuffers::String *container() const
8309   {
8310     return GetPointer<const flatbuffers::String *>(VT_CONTAINER);
8311   }
8312   const flatbuffers::String *shared_name() const
8313   {
8314     return GetPointer<const flatbuffers::String *>(VT_SHARED_NAME);
8315   }
8316   bool Verify(flatbuffers::Verifier &verifier) const
8317   {
8318     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CONTAINER) &&
8319            verifier.VerifyString(container()) && VerifyOffset(verifier, VT_SHARED_NAME) &&
8320            verifier.VerifyString(shared_name()) && verifier.EndTable();
8321   }
8322 };
8323
8324 struct VarHandleOptionsBuilder
8325 {
8326   typedef VarHandleOptions Table;
8327   flatbuffers::FlatBufferBuilder &fbb_;
8328   flatbuffers::uoffset_t start_;
8329   void add_container(flatbuffers::Offset<flatbuffers::String> container)
8330   {
8331     fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container);
8332   }
8333   void add_shared_name(flatbuffers::Offset<flatbuffers::String> shared_name)
8334   {
8335     fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name);
8336   }
8337   explicit VarHandleOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8338   {
8339     start_ = fbb_.StartTable();
8340   }
8341   flatbuffers::Offset<VarHandleOptions> Finish()
8342   {
8343     const auto end = fbb_.EndTable(start_);
8344     auto o = flatbuffers::Offset<VarHandleOptions>(end);
8345     return o;
8346   }
8347 };
8348
8349 inline flatbuffers::Offset<VarHandleOptions>
8350 CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb,
8351                        flatbuffers::Offset<flatbuffers::String> container = 0,
8352                        flatbuffers::Offset<flatbuffers::String> shared_name = 0)
8353 {
8354   VarHandleOptionsBuilder builder_(_fbb);
8355   builder_.add_shared_name(shared_name);
8356   builder_.add_container(container);
8357   return builder_.Finish();
8358 }
8359
8360 inline flatbuffers::Offset<VarHandleOptions>
8361 CreateVarHandleOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *container = nullptr,
8362                              const char *shared_name = nullptr)
8363 {
8364   auto container__ = container ? _fbb.CreateString(container) : 0;
8365   auto shared_name__ = shared_name ? _fbb.CreateString(shared_name) : 0;
8366   return onert_tflite::CreateVarHandleOptions(_fbb, container__, shared_name__);
8367 }
8368
8369 struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8370 {
8371   typedef ReadVariableOptionsBuilder Builder;
8372   bool Verify(flatbuffers::Verifier &verifier) const
8373   {
8374     return VerifyTableStart(verifier) && verifier.EndTable();
8375   }
8376 };
8377
8378 struct ReadVariableOptionsBuilder
8379 {
8380   typedef ReadVariableOptions Table;
8381   flatbuffers::FlatBufferBuilder &fbb_;
8382   flatbuffers::uoffset_t start_;
8383   explicit ReadVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8384   {
8385     start_ = fbb_.StartTable();
8386   }
8387   flatbuffers::Offset<ReadVariableOptions> Finish()
8388   {
8389     const auto end = fbb_.EndTable(start_);
8390     auto o = flatbuffers::Offset<ReadVariableOptions>(end);
8391     return o;
8392   }
8393 };
8394
8395 inline flatbuffers::Offset<ReadVariableOptions>
8396 CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
8397 {
8398   ReadVariableOptionsBuilder builder_(_fbb);
8399   return builder_.Finish();
8400 }
8401
8402 struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8403 {
8404   typedef AssignVariableOptionsBuilder Builder;
8405   bool Verify(flatbuffers::Verifier &verifier) const
8406   {
8407     return VerifyTableStart(verifier) && verifier.EndTable();
8408   }
8409 };
8410
8411 struct AssignVariableOptionsBuilder
8412 {
8413   typedef AssignVariableOptions Table;
8414   flatbuffers::FlatBufferBuilder &fbb_;
8415   flatbuffers::uoffset_t start_;
8416   explicit AssignVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8417   {
8418     start_ = fbb_.StartTable();
8419   }
8420   flatbuffers::Offset<AssignVariableOptions> Finish()
8421   {
8422     const auto end = fbb_.EndTable(start_);
8423     auto o = flatbuffers::Offset<AssignVariableOptions>(end);
8424     return o;
8425   }
8426 };
8427
8428 inline flatbuffers::Offset<AssignVariableOptions>
8429 CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
8430 {
8431   AssignVariableOptionsBuilder builder_(_fbb);
8432   return builder_.Finish();
8433 }
8434
8435 struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8436 {
8437   typedef RandomOptionsBuilder Builder;
8438   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8439   {
8440     VT_SEED = 4,
8441     VT_SEED2 = 6
8442   };
8443   int64_t seed() const { return GetField<int64_t>(VT_SEED, 0); }
8444   int64_t seed2() const { return GetField<int64_t>(VT_SEED2, 0); }
8445   bool Verify(flatbuffers::Verifier &verifier) const
8446   {
8447     return VerifyTableStart(verifier) && VerifyField<int64_t>(verifier, VT_SEED) &&
8448            VerifyField<int64_t>(verifier, VT_SEED2) && verifier.EndTable();
8449   }
8450 };
8451
8452 struct RandomOptionsBuilder
8453 {
8454   typedef RandomOptions Table;
8455   flatbuffers::FlatBufferBuilder &fbb_;
8456   flatbuffers::uoffset_t start_;
8457   void add_seed(int64_t seed) { fbb_.AddElement<int64_t>(RandomOptions::VT_SEED, seed, 0); }
8458   void add_seed2(int64_t seed2) { fbb_.AddElement<int64_t>(RandomOptions::VT_SEED2, seed2, 0); }
8459   explicit RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8460   {
8461     start_ = fbb_.StartTable();
8462   }
8463   flatbuffers::Offset<RandomOptions> Finish()
8464   {
8465     const auto end = fbb_.EndTable(start_);
8466     auto o = flatbuffers::Offset<RandomOptions>(end);
8467     return o;
8468   }
8469 };
8470
8471 inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb,
8472                                                               int64_t seed = 0, int64_t seed2 = 0)
8473 {
8474   RandomOptionsBuilder builder_(_fbb);
8475   builder_.add_seed2(seed2);
8476   builder_.add_seed(seed);
8477   return builder_.Finish();
8478 }
8479
8480 struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8481 {
8482   typedef BucketizeOptionsBuilder Builder;
8483   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8484   {
8485     VT_BOUNDARIES = 4
8486   };
8487   const flatbuffers::Vector<float> *boundaries() const
8488   {
8489     return GetPointer<const flatbuffers::Vector<float> *>(VT_BOUNDARIES);
8490   }
8491   bool Verify(flatbuffers::Verifier &verifier) const
8492   {
8493     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BOUNDARIES) &&
8494            verifier.VerifyVector(boundaries()) && verifier.EndTable();
8495   }
8496 };
8497
8498 struct BucketizeOptionsBuilder
8499 {
8500   typedef BucketizeOptions Table;
8501   flatbuffers::FlatBufferBuilder &fbb_;
8502   flatbuffers::uoffset_t start_;
8503   void add_boundaries(flatbuffers::Offset<flatbuffers::Vector<float>> boundaries)
8504   {
8505     fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries);
8506   }
8507   explicit BucketizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8508   {
8509     start_ = fbb_.StartTable();
8510   }
8511   flatbuffers::Offset<BucketizeOptions> Finish()
8512   {
8513     const auto end = fbb_.EndTable(start_);
8514     auto o = flatbuffers::Offset<BucketizeOptions>(end);
8515     return o;
8516   }
8517 };
8518
8519 inline flatbuffers::Offset<BucketizeOptions>
8520 CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb,
8521                        flatbuffers::Offset<flatbuffers::Vector<float>> boundaries = 0)
8522 {
8523   BucketizeOptionsBuilder builder_(_fbb);
8524   builder_.add_boundaries(boundaries);
8525   return builder_.Finish();
8526 }
8527
8528 inline flatbuffers::Offset<BucketizeOptions>
8529 CreateBucketizeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
8530                              const std::vector<float> *boundaries = nullptr)
8531 {
8532   auto boundaries__ = boundaries ? _fbb.CreateVector<float>(*boundaries) : 0;
8533   return onert_tflite::CreateBucketizeOptions(_fbb, boundaries__);
8534 }
8535
8536 struct GeluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8537 {
8538   typedef GeluOptionsBuilder Builder;
8539   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8540   {
8541     VT_APPROXIMATE = 4
8542   };
8543   bool approximate() const { return GetField<uint8_t>(VT_APPROXIMATE, 0) != 0; }
8544   bool Verify(flatbuffers::Verifier &verifier) const
8545   {
8546     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_APPROXIMATE) &&
8547            verifier.EndTable();
8548   }
8549 };
8550
8551 struct GeluOptionsBuilder
8552 {
8553   typedef GeluOptions Table;
8554   flatbuffers::FlatBufferBuilder &fbb_;
8555   flatbuffers::uoffset_t start_;
8556   void add_approximate(bool approximate)
8557   {
8558     fbb_.AddElement<uint8_t>(GeluOptions::VT_APPROXIMATE, static_cast<uint8_t>(approximate), 0);
8559   }
8560   explicit GeluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8561   {
8562     start_ = fbb_.StartTable();
8563   }
8564   flatbuffers::Offset<GeluOptions> Finish()
8565   {
8566     const auto end = fbb_.EndTable(start_);
8567     auto o = flatbuffers::Offset<GeluOptions>(end);
8568     return o;
8569   }
8570 };
8571
8572 inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb,
8573                                                           bool approximate = false)
8574 {
8575   GeluOptionsBuilder builder_(_fbb);
8576   builder_.add_approximate(approximate);
8577   return builder_.Finish();
8578 }
8579
8580 struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8581 {
8582   typedef DynamicUpdateSliceOptionsBuilder Builder;
8583   bool Verify(flatbuffers::Verifier &verifier) const
8584   {
8585     return VerifyTableStart(verifier) && verifier.EndTable();
8586   }
8587 };
8588
8589 struct DynamicUpdateSliceOptionsBuilder
8590 {
8591   typedef DynamicUpdateSliceOptions Table;
8592   flatbuffers::FlatBufferBuilder &fbb_;
8593   flatbuffers::uoffset_t start_;
8594   explicit DynamicUpdateSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8595   {
8596     start_ = fbb_.StartTable();
8597   }
8598   flatbuffers::Offset<DynamicUpdateSliceOptions> Finish()
8599   {
8600     const auto end = fbb_.EndTable(start_);
8601     auto o = flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
8602     return o;
8603   }
8604 };
8605
8606 inline flatbuffers::Offset<DynamicUpdateSliceOptions>
8607 CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
8608 {
8609   DynamicUpdateSliceOptionsBuilder builder_(_fbb);
8610   return builder_.Finish();
8611 }
8612
8613 struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8614 {
8615   typedef UnsortedSegmentProdOptionsBuilder Builder;
8616   bool Verify(flatbuffers::Verifier &verifier) const
8617   {
8618     return VerifyTableStart(verifier) && verifier.EndTable();
8619   }
8620 };
8621
8622 struct UnsortedSegmentProdOptionsBuilder
8623 {
8624   typedef UnsortedSegmentProdOptions Table;
8625   flatbuffers::FlatBufferBuilder &fbb_;
8626   flatbuffers::uoffset_t start_;
8627   explicit UnsortedSegmentProdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8628   {
8629     start_ = fbb_.StartTable();
8630   }
8631   flatbuffers::Offset<UnsortedSegmentProdOptions> Finish()
8632   {
8633     const auto end = fbb_.EndTable(start_);
8634     auto o = flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
8635     return o;
8636   }
8637 };
8638
8639 inline flatbuffers::Offset<UnsortedSegmentProdOptions>
8640 CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb)
8641 {
8642   UnsortedSegmentProdOptionsBuilder builder_(_fbb);
8643   return builder_.Finish();
8644 }
8645
8646 struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8647 {
8648   typedef UnsortedSegmentMaxOptionsBuilder Builder;
8649   bool Verify(flatbuffers::Verifier &verifier) const
8650   {
8651     return VerifyTableStart(verifier) && verifier.EndTable();
8652   }
8653 };
8654
8655 struct UnsortedSegmentMaxOptionsBuilder
8656 {
8657   typedef UnsortedSegmentMaxOptions Table;
8658   flatbuffers::FlatBufferBuilder &fbb_;
8659   flatbuffers::uoffset_t start_;
8660   explicit UnsortedSegmentMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8661   {
8662     start_ = fbb_.StartTable();
8663   }
8664   flatbuffers::Offset<UnsortedSegmentMaxOptions> Finish()
8665   {
8666     const auto end = fbb_.EndTable(start_);
8667     auto o = flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
8668     return o;
8669   }
8670 };
8671
8672 inline flatbuffers::Offset<UnsortedSegmentMaxOptions>
8673 CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
8674 {
8675   UnsortedSegmentMaxOptionsBuilder builder_(_fbb);
8676   return builder_.Finish();
8677 }
8678
8679 struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8680 {
8681   typedef UnsortedSegmentSumOptionsBuilder Builder;
8682   bool Verify(flatbuffers::Verifier &verifier) const
8683   {
8684     return VerifyTableStart(verifier) && verifier.EndTable();
8685   }
8686 };
8687
8688 struct UnsortedSegmentSumOptionsBuilder
8689 {
8690   typedef UnsortedSegmentSumOptions Table;
8691   flatbuffers::FlatBufferBuilder &fbb_;
8692   flatbuffers::uoffset_t start_;
8693   explicit UnsortedSegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8694   {
8695     start_ = fbb_.StartTable();
8696   }
8697   flatbuffers::Offset<UnsortedSegmentSumOptions> Finish()
8698   {
8699     const auto end = fbb_.EndTable(start_);
8700     auto o = flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
8701     return o;
8702   }
8703 };
8704
8705 inline flatbuffers::Offset<UnsortedSegmentSumOptions>
8706 CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
8707 {
8708   UnsortedSegmentSumOptionsBuilder builder_(_fbb);
8709   return builder_.Finish();
8710 }
8711
8712 struct ATan2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8713 {
8714   typedef ATan2OptionsBuilder Builder;
8715   bool Verify(flatbuffers::Verifier &verifier) const
8716   {
8717     return VerifyTableStart(verifier) && verifier.EndTable();
8718   }
8719 };
8720
8721 struct ATan2OptionsBuilder
8722 {
8723   typedef ATan2Options Table;
8724   flatbuffers::FlatBufferBuilder &fbb_;
8725   flatbuffers::uoffset_t start_;
8726   explicit ATan2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8727   {
8728     start_ = fbb_.StartTable();
8729   }
8730   flatbuffers::Offset<ATan2Options> Finish()
8731   {
8732     const auto end = fbb_.EndTable(start_);
8733     auto o = flatbuffers::Offset<ATan2Options>(end);
8734     return o;
8735   }
8736 };
8737
8738 inline flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb)
8739 {
8740   ATan2OptionsBuilder builder_(_fbb);
8741   return builder_.Finish();
8742 }
8743
8744 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8745 {
8746   typedef OperatorCodeBuilder Builder;
8747   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8748   {
8749     VT_DEPRECATED_BUILTIN_CODE = 4,
8750     VT_CUSTOM_CODE = 6,
8751     VT_VERSION = 8,
8752     VT_BUILTIN_CODE = 10
8753   };
8754   int8_t deprecated_builtin_code() const { return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0); }
8755   const flatbuffers::String *custom_code() const
8756   {
8757     return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
8758   }
8759   int32_t version() const { return GetField<int32_t>(VT_VERSION, 1); }
8760   onert_tflite::BuiltinOperator builtin_code() const
8761   {
8762     return static_cast<onert_tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
8763   }
8764   bool Verify(flatbuffers::Verifier &verifier) const
8765   {
8766     return VerifyTableStart(verifier) &&
8767            VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE) &&
8768            VerifyOffset(verifier, VT_CUSTOM_CODE) && verifier.VerifyString(custom_code()) &&
8769            VerifyField<int32_t>(verifier, VT_VERSION) &&
8770            VerifyField<int32_t>(verifier, VT_BUILTIN_CODE) && verifier.EndTable();
8771   }
8772 };
8773
8774 struct OperatorCodeBuilder
8775 {
8776   typedef OperatorCode Table;
8777   flatbuffers::FlatBufferBuilder &fbb_;
8778   flatbuffers::uoffset_t start_;
8779   void add_deprecated_builtin_code(int8_t deprecated_builtin_code)
8780   {
8781     fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
8782   }
8783   void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code)
8784   {
8785     fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
8786   }
8787   void add_version(int32_t version)
8788   {
8789     fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
8790   }
8791   void add_builtin_code(onert_tflite::BuiltinOperator builtin_code)
8792   {
8793     fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
8794   }
8795   explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8796   {
8797     start_ = fbb_.StartTable();
8798   }
8799   flatbuffers::Offset<OperatorCode> Finish()
8800   {
8801     const auto end = fbb_.EndTable(start_);
8802     auto o = flatbuffers::Offset<OperatorCode>(end);
8803     return o;
8804   }
8805 };
8806
8807 inline flatbuffers::Offset<OperatorCode>
8808 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0,
8809                    flatbuffers::Offset<flatbuffers::String> custom_code = 0, int32_t version = 1,
8810                    onert_tflite::BuiltinOperator builtin_code = onert_tflite::BuiltinOperator_ADD)
8811 {
8812   OperatorCodeBuilder builder_(_fbb);
8813   builder_.add_builtin_code(builtin_code);
8814   builder_.add_version(version);
8815   builder_.add_custom_code(custom_code);
8816   builder_.add_deprecated_builtin_code(deprecated_builtin_code);
8817   return builder_.Finish();
8818 }
8819
8820 inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
8821   flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0,
8822   const char *custom_code = nullptr, int32_t version = 1,
8823   onert_tflite::BuiltinOperator builtin_code = onert_tflite::BuiltinOperator_ADD)
8824 {
8825   auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
8826   return onert_tflite::CreateOperatorCode(_fbb, deprecated_builtin_code, custom_code__, version,
8827                                           builtin_code);
8828 }
8829
8830 struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8831 {
8832   typedef OperatorBuilder Builder;
8833   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8834   {
8835     VT_OPCODE_INDEX = 4,
8836     VT_INPUTS = 6,
8837     VT_OUTPUTS = 8,
8838     VT_BUILTIN_OPTIONS_TYPE = 10,
8839     VT_BUILTIN_OPTIONS = 12,
8840     VT_CUSTOM_OPTIONS = 14,
8841     VT_CUSTOM_OPTIONS_FORMAT = 16,
8842     VT_MUTATING_VARIABLE_INPUTS = 18,
8843     VT_INTERMEDIATES = 20
8844   };
8845   uint32_t opcode_index() const { return GetField<uint32_t>(VT_OPCODE_INDEX, 0); }
8846   const flatbuffers::Vector<int32_t> *inputs() const
8847   {
8848     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
8849   }
8850   const flatbuffers::Vector<int32_t> *outputs() const
8851   {
8852     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
8853   }
8854   onert_tflite::BuiltinOptions builtin_options_type() const
8855   {
8856     return static_cast<onert_tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
8857   }
8858   const void *builtin_options() const { return GetPointer<const void *>(VT_BUILTIN_OPTIONS); }
8859   template <typename T> const T *builtin_options_as() const;
8860   const onert_tflite::Conv2DOptions *builtin_options_as_Conv2DOptions() const
8861   {
8862     return builtin_options_type() == onert_tflite::BuiltinOptions_Conv2DOptions
8863              ? static_cast<const onert_tflite::Conv2DOptions *>(builtin_options())
8864              : nullptr;
8865   }
8866   const onert_tflite::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const
8867   {
8868     return builtin_options_type() == onert_tflite::BuiltinOptions_DepthwiseConv2DOptions
8869              ? static_cast<const onert_tflite::DepthwiseConv2DOptions *>(builtin_options())
8870              : nullptr;
8871   }
8872   const onert_tflite::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const
8873   {
8874     return builtin_options_type() == onert_tflite::BuiltinOptions_ConcatEmbeddingsOptions
8875              ? static_cast<const onert_tflite::ConcatEmbeddingsOptions *>(builtin_options())
8876              : nullptr;
8877   }
8878   const onert_tflite::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const
8879   {
8880     return builtin_options_type() == onert_tflite::BuiltinOptions_LSHProjectionOptions
8881              ? static_cast<const onert_tflite::LSHProjectionOptions *>(builtin_options())
8882              : nullptr;
8883   }
8884   const onert_tflite::Pool2DOptions *builtin_options_as_Pool2DOptions() const
8885   {
8886     return builtin_options_type() == onert_tflite::BuiltinOptions_Pool2DOptions
8887              ? static_cast<const onert_tflite::Pool2DOptions *>(builtin_options())
8888              : nullptr;
8889   }
8890   const onert_tflite::SVDFOptions *builtin_options_as_SVDFOptions() const
8891   {
8892     return builtin_options_type() == onert_tflite::BuiltinOptions_SVDFOptions
8893              ? static_cast<const onert_tflite::SVDFOptions *>(builtin_options())
8894              : nullptr;
8895   }
8896   const onert_tflite::RNNOptions *builtin_options_as_RNNOptions() const
8897   {
8898     return builtin_options_type() == onert_tflite::BuiltinOptions_RNNOptions
8899              ? static_cast<const onert_tflite::RNNOptions *>(builtin_options())
8900              : nullptr;
8901   }
8902   const onert_tflite::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const
8903   {
8904     return builtin_options_type() == onert_tflite::BuiltinOptions_FullyConnectedOptions
8905              ? static_cast<const onert_tflite::FullyConnectedOptions *>(builtin_options())
8906              : nullptr;
8907   }
8908   const onert_tflite::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const
8909   {
8910     return builtin_options_type() == onert_tflite::BuiltinOptions_SoftmaxOptions
8911              ? static_cast<const onert_tflite::SoftmaxOptions *>(builtin_options())
8912              : nullptr;
8913   }
8914   const onert_tflite::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const
8915   {
8916     return builtin_options_type() == onert_tflite::BuiltinOptions_ConcatenationOptions
8917              ? static_cast<const onert_tflite::ConcatenationOptions *>(builtin_options())
8918              : nullptr;
8919   }
8920   const onert_tflite::AddOptions *builtin_options_as_AddOptions() const
8921   {
8922     return builtin_options_type() == onert_tflite::BuiltinOptions_AddOptions
8923              ? static_cast<const onert_tflite::AddOptions *>(builtin_options())
8924              : nullptr;
8925   }
8926   const onert_tflite::L2NormOptions *builtin_options_as_L2NormOptions() const
8927   {
8928     return builtin_options_type() == onert_tflite::BuiltinOptions_L2NormOptions
8929              ? static_cast<const onert_tflite::L2NormOptions *>(builtin_options())
8930              : nullptr;
8931   }
8932   const onert_tflite::LocalResponseNormalizationOptions *
8933   builtin_options_as_LocalResponseNormalizationOptions() const
8934   {
8935     return builtin_options_type() == onert_tflite::BuiltinOptions_LocalResponseNormalizationOptions
8936              ? static_cast<const onert_tflite::LocalResponseNormalizationOptions *>(
8937                  builtin_options())
8938              : nullptr;
8939   }
8940   const onert_tflite::LSTMOptions *builtin_options_as_LSTMOptions() const
8941   {
8942     return builtin_options_type() == onert_tflite::BuiltinOptions_LSTMOptions
8943              ? static_cast<const onert_tflite::LSTMOptions *>(builtin_options())
8944              : nullptr;
8945   }
8946   const onert_tflite::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const
8947   {
8948     return builtin_options_type() == onert_tflite::BuiltinOptions_ResizeBilinearOptions
8949              ? static_cast<const onert_tflite::ResizeBilinearOptions *>(builtin_options())
8950              : nullptr;
8951   }
8952   const onert_tflite::CallOptions *builtin_options_as_CallOptions() const
8953   {
8954     return builtin_options_type() == onert_tflite::BuiltinOptions_CallOptions
8955              ? static_cast<const onert_tflite::CallOptions *>(builtin_options())
8956              : nullptr;
8957   }
8958   const onert_tflite::ReshapeOptions *builtin_options_as_ReshapeOptions() const
8959   {
8960     return builtin_options_type() == onert_tflite::BuiltinOptions_ReshapeOptions
8961              ? static_cast<const onert_tflite::ReshapeOptions *>(builtin_options())
8962              : nullptr;
8963   }
8964   const onert_tflite::SkipGramOptions *builtin_options_as_SkipGramOptions() const
8965   {
8966     return builtin_options_type() == onert_tflite::BuiltinOptions_SkipGramOptions
8967              ? static_cast<const onert_tflite::SkipGramOptions *>(builtin_options())
8968              : nullptr;
8969   }
8970   const onert_tflite::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const
8971   {
8972     return builtin_options_type() == onert_tflite::BuiltinOptions_SpaceToDepthOptions
8973              ? static_cast<const onert_tflite::SpaceToDepthOptions *>(builtin_options())
8974              : nullptr;
8975   }
8976   const onert_tflite::EmbeddingLookupSparseOptions *
8977   builtin_options_as_EmbeddingLookupSparseOptions() const
8978   {
8979     return builtin_options_type() == onert_tflite::BuiltinOptions_EmbeddingLookupSparseOptions
8980              ? static_cast<const onert_tflite::EmbeddingLookupSparseOptions *>(builtin_options())
8981              : nullptr;
8982   }
8983   const onert_tflite::MulOptions *builtin_options_as_MulOptions() const
8984   {
8985     return builtin_options_type() == onert_tflite::BuiltinOptions_MulOptions
8986              ? static_cast<const onert_tflite::MulOptions *>(builtin_options())
8987              : nullptr;
8988   }
8989   const onert_tflite::PadOptions *builtin_options_as_PadOptions() const
8990   {
8991     return builtin_options_type() == onert_tflite::BuiltinOptions_PadOptions
8992              ? static_cast<const onert_tflite::PadOptions *>(builtin_options())
8993              : nullptr;
8994   }
8995   const onert_tflite::GatherOptions *builtin_options_as_GatherOptions() const
8996   {
8997     return builtin_options_type() == onert_tflite::BuiltinOptions_GatherOptions
8998              ? static_cast<const onert_tflite::GatherOptions *>(builtin_options())
8999              : nullptr;
9000   }
9001   const onert_tflite::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const
9002   {
9003     return builtin_options_type() == onert_tflite::BuiltinOptions_BatchToSpaceNDOptions
9004              ? static_cast<const onert_tflite::BatchToSpaceNDOptions *>(builtin_options())
9005              : nullptr;
9006   }
9007   const onert_tflite::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const
9008   {
9009     return builtin_options_type() == onert_tflite::BuiltinOptions_SpaceToBatchNDOptions
9010              ? static_cast<const onert_tflite::SpaceToBatchNDOptions *>(builtin_options())
9011              : nullptr;
9012   }
9013   const onert_tflite::TransposeOptions *builtin_options_as_TransposeOptions() const
9014   {
9015     return builtin_options_type() == onert_tflite::BuiltinOptions_TransposeOptions
9016              ? static_cast<const onert_tflite::TransposeOptions *>(builtin_options())
9017              : nullptr;
9018   }
9019   const onert_tflite::ReducerOptions *builtin_options_as_ReducerOptions() const
9020   {
9021     return builtin_options_type() == onert_tflite::BuiltinOptions_ReducerOptions
9022              ? static_cast<const onert_tflite::ReducerOptions *>(builtin_options())
9023              : nullptr;
9024   }
9025   const onert_tflite::SubOptions *builtin_options_as_SubOptions() const
9026   {
9027     return builtin_options_type() == onert_tflite::BuiltinOptions_SubOptions
9028              ? static_cast<const onert_tflite::SubOptions *>(builtin_options())
9029              : nullptr;
9030   }
9031   const onert_tflite::DivOptions *builtin_options_as_DivOptions() const
9032   {
9033     return builtin_options_type() == onert_tflite::BuiltinOptions_DivOptions
9034              ? static_cast<const onert_tflite::DivOptions *>(builtin_options())
9035              : nullptr;
9036   }
9037   const onert_tflite::SqueezeOptions *builtin_options_as_SqueezeOptions() const
9038   {
9039     return builtin_options_type() == onert_tflite::BuiltinOptions_SqueezeOptions
9040              ? static_cast<const onert_tflite::SqueezeOptions *>(builtin_options())
9041              : nullptr;
9042   }
9043   const onert_tflite::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const
9044   {
9045     return builtin_options_type() == onert_tflite::BuiltinOptions_SequenceRNNOptions
9046              ? static_cast<const onert_tflite::SequenceRNNOptions *>(builtin_options())
9047              : nullptr;
9048   }
9049   const onert_tflite::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const
9050   {
9051     return builtin_options_type() == onert_tflite::BuiltinOptions_StridedSliceOptions
9052              ? static_cast<const onert_tflite::StridedSliceOptions *>(builtin_options())
9053              : nullptr;
9054   }
9055   const onert_tflite::ExpOptions *builtin_options_as_ExpOptions() const
9056   {
9057     return builtin_options_type() == onert_tflite::BuiltinOptions_ExpOptions
9058              ? static_cast<const onert_tflite::ExpOptions *>(builtin_options())
9059              : nullptr;
9060   }
9061   const onert_tflite::TopKV2Options *builtin_options_as_TopKV2Options() const
9062   {
9063     return builtin_options_type() == onert_tflite::BuiltinOptions_TopKV2Options
9064              ? static_cast<const onert_tflite::TopKV2Options *>(builtin_options())
9065              : nullptr;
9066   }
9067   const onert_tflite::SplitOptions *builtin_options_as_SplitOptions() const
9068   {
9069     return builtin_options_type() == onert_tflite::BuiltinOptions_SplitOptions
9070              ? static_cast<const onert_tflite::SplitOptions *>(builtin_options())
9071              : nullptr;
9072   }
9073   const onert_tflite::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const
9074   {
9075     return builtin_options_type() == onert_tflite::BuiltinOptions_LogSoftmaxOptions
9076              ? static_cast<const onert_tflite::LogSoftmaxOptions *>(builtin_options())
9077              : nullptr;
9078   }
9079   const onert_tflite::CastOptions *builtin_options_as_CastOptions() const
9080   {
9081     return builtin_options_type() == onert_tflite::BuiltinOptions_CastOptions
9082              ? static_cast<const onert_tflite::CastOptions *>(builtin_options())
9083              : nullptr;
9084   }
9085   const onert_tflite::DequantizeOptions *builtin_options_as_DequantizeOptions() const
9086   {
9087     return builtin_options_type() == onert_tflite::BuiltinOptions_DequantizeOptions
9088              ? static_cast<const onert_tflite::DequantizeOptions *>(builtin_options())
9089              : nullptr;
9090   }
9091   const onert_tflite::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const
9092   {
9093     return builtin_options_type() == onert_tflite::BuiltinOptions_MaximumMinimumOptions
9094              ? static_cast<const onert_tflite::MaximumMinimumOptions *>(builtin_options())
9095              : nullptr;
9096   }
9097   const onert_tflite::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const
9098   {
9099     return builtin_options_type() == onert_tflite::BuiltinOptions_ArgMaxOptions
9100              ? static_cast<const onert_tflite::ArgMaxOptions *>(builtin_options())
9101              : nullptr;
9102   }
9103   const onert_tflite::LessOptions *builtin_options_as_LessOptions() const
9104   {
9105     return builtin_options_type() == onert_tflite::BuiltinOptions_LessOptions
9106              ? static_cast<const onert_tflite::LessOptions *>(builtin_options())
9107              : nullptr;
9108   }
9109   const onert_tflite::NegOptions *builtin_options_as_NegOptions() const
9110   {
9111     return builtin_options_type() == onert_tflite::BuiltinOptions_NegOptions
9112              ? static_cast<const onert_tflite::NegOptions *>(builtin_options())
9113              : nullptr;
9114   }
9115   const onert_tflite::PadV2Options *builtin_options_as_PadV2Options() const
9116   {
9117     return builtin_options_type() == onert_tflite::BuiltinOptions_PadV2Options
9118              ? static_cast<const onert_tflite::PadV2Options *>(builtin_options())
9119              : nullptr;
9120   }
9121   const onert_tflite::GreaterOptions *builtin_options_as_GreaterOptions() const
9122   {
9123     return builtin_options_type() == onert_tflite::BuiltinOptions_GreaterOptions
9124              ? static_cast<const onert_tflite::GreaterOptions *>(builtin_options())
9125              : nullptr;
9126   }
9127   const onert_tflite::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const
9128   {
9129     return builtin_options_type() == onert_tflite::BuiltinOptions_GreaterEqualOptions
9130              ? static_cast<const onert_tflite::GreaterEqualOptions *>(builtin_options())
9131              : nullptr;
9132   }
9133   const onert_tflite::LessEqualOptions *builtin_options_as_LessEqualOptions() const
9134   {
9135     return builtin_options_type() == onert_tflite::BuiltinOptions_LessEqualOptions
9136              ? static_cast<const onert_tflite::LessEqualOptions *>(builtin_options())
9137              : nullptr;
9138   }
9139   const onert_tflite::SelectOptions *builtin_options_as_SelectOptions() const
9140   {
9141     return builtin_options_type() == onert_tflite::BuiltinOptions_SelectOptions
9142              ? static_cast<const onert_tflite::SelectOptions *>(builtin_options())
9143              : nullptr;
9144   }
9145   const onert_tflite::SliceOptions *builtin_options_as_SliceOptions() const
9146   {
9147     return builtin_options_type() == onert_tflite::BuiltinOptions_SliceOptions
9148              ? static_cast<const onert_tflite::SliceOptions *>(builtin_options())
9149              : nullptr;
9150   }
9151   const onert_tflite::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const
9152   {
9153     return builtin_options_type() == onert_tflite::BuiltinOptions_TransposeConvOptions
9154              ? static_cast<const onert_tflite::TransposeConvOptions *>(builtin_options())
9155              : nullptr;
9156   }
9157   const onert_tflite::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const
9158   {
9159     return builtin_options_type() == onert_tflite::BuiltinOptions_SparseToDenseOptions
9160              ? static_cast<const onert_tflite::SparseToDenseOptions *>(builtin_options())
9161              : nullptr;
9162   }
9163   const onert_tflite::TileOptions *builtin_options_as_TileOptions() const
9164   {
9165     return builtin_options_type() == onert_tflite::BuiltinOptions_TileOptions
9166              ? static_cast<const onert_tflite::TileOptions *>(builtin_options())
9167              : nullptr;
9168   }
9169   const onert_tflite::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const
9170   {
9171     return builtin_options_type() == onert_tflite::BuiltinOptions_ExpandDimsOptions
9172              ? static_cast<const onert_tflite::ExpandDimsOptions *>(builtin_options())
9173              : nullptr;
9174   }
9175   const onert_tflite::EqualOptions *builtin_options_as_EqualOptions() const
9176   {
9177     return builtin_options_type() == onert_tflite::BuiltinOptions_EqualOptions
9178              ? static_cast<const onert_tflite::EqualOptions *>(builtin_options())
9179              : nullptr;
9180   }
9181   const onert_tflite::NotEqualOptions *builtin_options_as_NotEqualOptions() const
9182   {
9183     return builtin_options_type() == onert_tflite::BuiltinOptions_NotEqualOptions
9184              ? static_cast<const onert_tflite::NotEqualOptions *>(builtin_options())
9185              : nullptr;
9186   }
9187   const onert_tflite::ShapeOptions *builtin_options_as_ShapeOptions() const
9188   {
9189     return builtin_options_type() == onert_tflite::BuiltinOptions_ShapeOptions
9190              ? static_cast<const onert_tflite::ShapeOptions *>(builtin_options())
9191              : nullptr;
9192   }
9193   const onert_tflite::PowOptions *builtin_options_as_PowOptions() const
9194   {
9195     return builtin_options_type() == onert_tflite::BuiltinOptions_PowOptions
9196              ? static_cast<const onert_tflite::PowOptions *>(builtin_options())
9197              : nullptr;
9198   }
9199   const onert_tflite::ArgMinOptions *builtin_options_as_ArgMinOptions() const
9200   {
9201     return builtin_options_type() == onert_tflite::BuiltinOptions_ArgMinOptions
9202              ? static_cast<const onert_tflite::ArgMinOptions *>(builtin_options())
9203              : nullptr;
9204   }
9205   const onert_tflite::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const
9206   {
9207     return builtin_options_type() == onert_tflite::BuiltinOptions_FakeQuantOptions
9208              ? static_cast<const onert_tflite::FakeQuantOptions *>(builtin_options())
9209              : nullptr;
9210   }
9211   const onert_tflite::PackOptions *builtin_options_as_PackOptions() const
9212   {
9213     return builtin_options_type() == onert_tflite::BuiltinOptions_PackOptions
9214              ? static_cast<const onert_tflite::PackOptions *>(builtin_options())
9215              : nullptr;
9216   }
9217   const onert_tflite::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const
9218   {
9219     return builtin_options_type() == onert_tflite::BuiltinOptions_LogicalOrOptions
9220              ? static_cast<const onert_tflite::LogicalOrOptions *>(builtin_options())
9221              : nullptr;
9222   }
9223   const onert_tflite::OneHotOptions *builtin_options_as_OneHotOptions() const
9224   {
9225     return builtin_options_type() == onert_tflite::BuiltinOptions_OneHotOptions
9226              ? static_cast<const onert_tflite::OneHotOptions *>(builtin_options())
9227              : nullptr;
9228   }
9229   const onert_tflite::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const
9230   {
9231     return builtin_options_type() == onert_tflite::BuiltinOptions_LogicalAndOptions
9232              ? static_cast<const onert_tflite::LogicalAndOptions *>(builtin_options())
9233              : nullptr;
9234   }
9235   const onert_tflite::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const
9236   {
9237     return builtin_options_type() == onert_tflite::BuiltinOptions_LogicalNotOptions
9238              ? static_cast<const onert_tflite::LogicalNotOptions *>(builtin_options())
9239              : nullptr;
9240   }
9241   const onert_tflite::UnpackOptions *builtin_options_as_UnpackOptions() const
9242   {
9243     return builtin_options_type() == onert_tflite::BuiltinOptions_UnpackOptions
9244              ? static_cast<const onert_tflite::UnpackOptions *>(builtin_options())
9245              : nullptr;
9246   }
9247   const onert_tflite::FloorDivOptions *builtin_options_as_FloorDivOptions() const
9248   {
9249     return builtin_options_type() == onert_tflite::BuiltinOptions_FloorDivOptions
9250              ? static_cast<const onert_tflite::FloorDivOptions *>(builtin_options())
9251              : nullptr;
9252   }
9253   const onert_tflite::SquareOptions *builtin_options_as_SquareOptions() const
9254   {
9255     return builtin_options_type() == onert_tflite::BuiltinOptions_SquareOptions
9256              ? static_cast<const onert_tflite::SquareOptions *>(builtin_options())
9257              : nullptr;
9258   }
9259   const onert_tflite::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const
9260   {
9261     return builtin_options_type() == onert_tflite::BuiltinOptions_ZerosLikeOptions
9262              ? static_cast<const onert_tflite::ZerosLikeOptions *>(builtin_options())
9263              : nullptr;
9264   }
9265   const onert_tflite::FillOptions *builtin_options_as_FillOptions() const
9266   {
9267     return builtin_options_type() == onert_tflite::BuiltinOptions_FillOptions
9268              ? static_cast<const onert_tflite::FillOptions *>(builtin_options())
9269              : nullptr;
9270   }
9271   const onert_tflite::BidirectionalSequenceLSTMOptions *
9272   builtin_options_as_BidirectionalSequenceLSTMOptions() const
9273   {
9274     return builtin_options_type() == onert_tflite::BuiltinOptions_BidirectionalSequenceLSTMOptions
9275              ? static_cast<const onert_tflite::BidirectionalSequenceLSTMOptions *>(
9276                  builtin_options())
9277              : nullptr;
9278   }
9279   const onert_tflite::BidirectionalSequenceRNNOptions *
9280   builtin_options_as_BidirectionalSequenceRNNOptions() const
9281   {
9282     return builtin_options_type() == onert_tflite::BuiltinOptions_BidirectionalSequenceRNNOptions
9283              ? static_cast<const onert_tflite::BidirectionalSequenceRNNOptions *>(builtin_options())
9284              : nullptr;
9285   }
9286   const onert_tflite::UnidirectionalSequenceLSTMOptions *
9287   builtin_options_as_UnidirectionalSequenceLSTMOptions() const
9288   {
9289     return builtin_options_type() == onert_tflite::BuiltinOptions_UnidirectionalSequenceLSTMOptions
9290              ? static_cast<const onert_tflite::UnidirectionalSequenceLSTMOptions *>(
9291                  builtin_options())
9292              : nullptr;
9293   }
9294   const onert_tflite::FloorModOptions *builtin_options_as_FloorModOptions() const
9295   {
9296     return builtin_options_type() == onert_tflite::BuiltinOptions_FloorModOptions
9297              ? static_cast<const onert_tflite::FloorModOptions *>(builtin_options())
9298              : nullptr;
9299   }
9300   const onert_tflite::RangeOptions *builtin_options_as_RangeOptions() const
9301   {
9302     return builtin_options_type() == onert_tflite::BuiltinOptions_RangeOptions
9303              ? static_cast<const onert_tflite::RangeOptions *>(builtin_options())
9304              : nullptr;
9305   }
9306   const onert_tflite::ResizeNearestNeighborOptions *
9307   builtin_options_as_ResizeNearestNeighborOptions() const
9308   {
9309     return builtin_options_type() == onert_tflite::BuiltinOptions_ResizeNearestNeighborOptions
9310              ? static_cast<const onert_tflite::ResizeNearestNeighborOptions *>(builtin_options())
9311              : nullptr;
9312   }
9313   const onert_tflite::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const
9314   {
9315     return builtin_options_type() == onert_tflite::BuiltinOptions_LeakyReluOptions
9316              ? static_cast<const onert_tflite::LeakyReluOptions *>(builtin_options())
9317              : nullptr;
9318   }
9319   const onert_tflite::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const
9320   {
9321     return builtin_options_type() == onert_tflite::BuiltinOptions_SquaredDifferenceOptions
9322              ? static_cast<const onert_tflite::SquaredDifferenceOptions *>(builtin_options())
9323              : nullptr;
9324   }
9325   const onert_tflite::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const
9326   {
9327     return builtin_options_type() == onert_tflite::BuiltinOptions_MirrorPadOptions
9328              ? static_cast<const onert_tflite::MirrorPadOptions *>(builtin_options())
9329              : nullptr;
9330   }
9331   const onert_tflite::AbsOptions *builtin_options_as_AbsOptions() const
9332   {
9333     return builtin_options_type() == onert_tflite::BuiltinOptions_AbsOptions
9334              ? static_cast<const onert_tflite::AbsOptions *>(builtin_options())
9335              : nullptr;
9336   }
9337   const onert_tflite::SplitVOptions *builtin_options_as_SplitVOptions() const
9338   {
9339     return builtin_options_type() == onert_tflite::BuiltinOptions_SplitVOptions
9340              ? static_cast<const onert_tflite::SplitVOptions *>(builtin_options())
9341              : nullptr;
9342   }
9343   const onert_tflite::UniqueOptions *builtin_options_as_UniqueOptions() const
9344   {
9345     return builtin_options_type() == onert_tflite::BuiltinOptions_UniqueOptions
9346              ? static_cast<const onert_tflite::UniqueOptions *>(builtin_options())
9347              : nullptr;
9348   }
9349   const onert_tflite::ReverseV2Options *builtin_options_as_ReverseV2Options() const
9350   {
9351     return builtin_options_type() == onert_tflite::BuiltinOptions_ReverseV2Options
9352              ? static_cast<const onert_tflite::ReverseV2Options *>(builtin_options())
9353              : nullptr;
9354   }
9355   const onert_tflite::AddNOptions *builtin_options_as_AddNOptions() const
9356   {
9357     return builtin_options_type() == onert_tflite::BuiltinOptions_AddNOptions
9358              ? static_cast<const onert_tflite::AddNOptions *>(builtin_options())
9359              : nullptr;
9360   }
9361   const onert_tflite::GatherNdOptions *builtin_options_as_GatherNdOptions() const
9362   {
9363     return builtin_options_type() == onert_tflite::BuiltinOptions_GatherNdOptions
9364              ? static_cast<const onert_tflite::GatherNdOptions *>(builtin_options())
9365              : nullptr;
9366   }
9367   const onert_tflite::CosOptions *builtin_options_as_CosOptions() const
9368   {
9369     return builtin_options_type() == onert_tflite::BuiltinOptions_CosOptions
9370              ? static_cast<const onert_tflite::CosOptions *>(builtin_options())
9371              : nullptr;
9372   }
9373   const onert_tflite::WhereOptions *builtin_options_as_WhereOptions() const
9374   {
9375     return builtin_options_type() == onert_tflite::BuiltinOptions_WhereOptions
9376              ? static_cast<const onert_tflite::WhereOptions *>(builtin_options())
9377              : nullptr;
9378   }
9379   const onert_tflite::RankOptions *builtin_options_as_RankOptions() const
9380   {
9381     return builtin_options_type() == onert_tflite::BuiltinOptions_RankOptions
9382              ? static_cast<const onert_tflite::RankOptions *>(builtin_options())
9383              : nullptr;
9384   }
9385   const onert_tflite::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const
9386   {
9387     return builtin_options_type() == onert_tflite::BuiltinOptions_ReverseSequenceOptions
9388              ? static_cast<const onert_tflite::ReverseSequenceOptions *>(builtin_options())
9389              : nullptr;
9390   }
9391   const onert_tflite::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const
9392   {
9393     return builtin_options_type() == onert_tflite::BuiltinOptions_MatrixDiagOptions
9394              ? static_cast<const onert_tflite::MatrixDiagOptions *>(builtin_options())
9395              : nullptr;
9396   }
9397   const onert_tflite::QuantizeOptions *builtin_options_as_QuantizeOptions() const
9398   {
9399     return builtin_options_type() == onert_tflite::BuiltinOptions_QuantizeOptions
9400              ? static_cast<const onert_tflite::QuantizeOptions *>(builtin_options())
9401              : nullptr;
9402   }
9403   const onert_tflite::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const
9404   {
9405     return builtin_options_type() == onert_tflite::BuiltinOptions_MatrixSetDiagOptions
9406              ? static_cast<const onert_tflite::MatrixSetDiagOptions *>(builtin_options())
9407              : nullptr;
9408   }
9409   const onert_tflite::HardSwishOptions *builtin_options_as_HardSwishOptions() const
9410   {
9411     return builtin_options_type() == onert_tflite::BuiltinOptions_HardSwishOptions
9412              ? static_cast<const onert_tflite::HardSwishOptions *>(builtin_options())
9413              : nullptr;
9414   }
9415   const onert_tflite::IfOptions *builtin_options_as_IfOptions() const
9416   {
9417     return builtin_options_type() == onert_tflite::BuiltinOptions_IfOptions
9418              ? static_cast<const onert_tflite::IfOptions *>(builtin_options())
9419              : nullptr;
9420   }
9421   const onert_tflite::WhileOptions *builtin_options_as_WhileOptions() const
9422   {
9423     return builtin_options_type() == onert_tflite::BuiltinOptions_WhileOptions
9424              ? static_cast<const onert_tflite::WhileOptions *>(builtin_options())
9425              : nullptr;
9426   }
9427   const onert_tflite::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const
9428   {
9429     return builtin_options_type() == onert_tflite::BuiltinOptions_DepthToSpaceOptions
9430              ? static_cast<const onert_tflite::DepthToSpaceOptions *>(builtin_options())
9431              : nullptr;
9432   }
9433   const onert_tflite::NonMaxSuppressionV4Options *
9434   builtin_options_as_NonMaxSuppressionV4Options() const
9435   {
9436     return builtin_options_type() == onert_tflite::BuiltinOptions_NonMaxSuppressionV4Options
9437              ? static_cast<const onert_tflite::NonMaxSuppressionV4Options *>(builtin_options())
9438              : nullptr;
9439   }
9440   const onert_tflite::NonMaxSuppressionV5Options *
9441   builtin_options_as_NonMaxSuppressionV5Options() const
9442   {
9443     return builtin_options_type() == onert_tflite::BuiltinOptions_NonMaxSuppressionV5Options
9444              ? static_cast<const onert_tflite::NonMaxSuppressionV5Options *>(builtin_options())
9445              : nullptr;
9446   }
9447   const onert_tflite::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const
9448   {
9449     return builtin_options_type() == onert_tflite::BuiltinOptions_ScatterNdOptions
9450              ? static_cast<const onert_tflite::ScatterNdOptions *>(builtin_options())
9451              : nullptr;
9452   }
9453   const onert_tflite::SelectV2Options *builtin_options_as_SelectV2Options() const
9454   {
9455     return builtin_options_type() == onert_tflite::BuiltinOptions_SelectV2Options
9456              ? static_cast<const onert_tflite::SelectV2Options *>(builtin_options())
9457              : nullptr;
9458   }
9459   const onert_tflite::DensifyOptions *builtin_options_as_DensifyOptions() const
9460   {
9461     return builtin_options_type() == onert_tflite::BuiltinOptions_DensifyOptions
9462              ? static_cast<const onert_tflite::DensifyOptions *>(builtin_options())
9463              : nullptr;
9464   }
9465   const onert_tflite::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const
9466   {
9467     return builtin_options_type() == onert_tflite::BuiltinOptions_SegmentSumOptions
9468              ? static_cast<const onert_tflite::SegmentSumOptions *>(builtin_options())
9469              : nullptr;
9470   }
9471   const onert_tflite::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const
9472   {
9473     return builtin_options_type() == onert_tflite::BuiltinOptions_BatchMatMulOptions
9474              ? static_cast<const onert_tflite::BatchMatMulOptions *>(builtin_options())
9475              : nullptr;
9476   }
9477   const onert_tflite::CumsumOptions *builtin_options_as_CumsumOptions() const
9478   {
9479     return builtin_options_type() == onert_tflite::BuiltinOptions_CumsumOptions
9480              ? static_cast<const onert_tflite::CumsumOptions *>(builtin_options())
9481              : nullptr;
9482   }
9483   const onert_tflite::CallOnceOptions *builtin_options_as_CallOnceOptions() const
9484   {
9485     return builtin_options_type() == onert_tflite::BuiltinOptions_CallOnceOptions
9486              ? static_cast<const onert_tflite::CallOnceOptions *>(builtin_options())
9487              : nullptr;
9488   }
9489   const onert_tflite::BroadcastToOptions *builtin_options_as_BroadcastToOptions() const
9490   {
9491     return builtin_options_type() == onert_tflite::BuiltinOptions_BroadcastToOptions
9492              ? static_cast<const onert_tflite::BroadcastToOptions *>(builtin_options())
9493              : nullptr;
9494   }
9495   const onert_tflite::Rfft2dOptions *builtin_options_as_Rfft2dOptions() const
9496   {
9497     return builtin_options_type() == onert_tflite::BuiltinOptions_Rfft2dOptions
9498              ? static_cast<const onert_tflite::Rfft2dOptions *>(builtin_options())
9499              : nullptr;
9500   }
9501   const onert_tflite::Conv3DOptions *builtin_options_as_Conv3DOptions() const
9502   {
9503     return builtin_options_type() == onert_tflite::BuiltinOptions_Conv3DOptions
9504              ? static_cast<const onert_tflite::Conv3DOptions *>(builtin_options())
9505              : nullptr;
9506   }
9507   const onert_tflite::HashtableOptions *builtin_options_as_HashtableOptions() const
9508   {
9509     return builtin_options_type() == onert_tflite::BuiltinOptions_HashtableOptions
9510              ? static_cast<const onert_tflite::HashtableOptions *>(builtin_options())
9511              : nullptr;
9512   }
9513   const onert_tflite::HashtableFindOptions *builtin_options_as_HashtableFindOptions() const
9514   {
9515     return builtin_options_type() == onert_tflite::BuiltinOptions_HashtableFindOptions
9516              ? static_cast<const onert_tflite::HashtableFindOptions *>(builtin_options())
9517              : nullptr;
9518   }
9519   const onert_tflite::HashtableImportOptions *builtin_options_as_HashtableImportOptions() const
9520   {
9521     return builtin_options_type() == onert_tflite::BuiltinOptions_HashtableImportOptions
9522              ? static_cast<const onert_tflite::HashtableImportOptions *>(builtin_options())
9523              : nullptr;
9524   }
9525   const onert_tflite::HashtableSizeOptions *builtin_options_as_HashtableSizeOptions() const
9526   {
9527     return builtin_options_type() == onert_tflite::BuiltinOptions_HashtableSizeOptions
9528              ? static_cast<const onert_tflite::HashtableSizeOptions *>(builtin_options())
9529              : nullptr;
9530   }
9531   const onert_tflite::VarHandleOptions *builtin_options_as_VarHandleOptions() const
9532   {
9533     return builtin_options_type() == onert_tflite::BuiltinOptions_VarHandleOptions
9534              ? static_cast<const onert_tflite::VarHandleOptions *>(builtin_options())
9535              : nullptr;
9536   }
9537   const onert_tflite::ReadVariableOptions *builtin_options_as_ReadVariableOptions() const
9538   {
9539     return builtin_options_type() == onert_tflite::BuiltinOptions_ReadVariableOptions
9540              ? static_cast<const onert_tflite::ReadVariableOptions *>(builtin_options())
9541              : nullptr;
9542   }
9543   const onert_tflite::AssignVariableOptions *builtin_options_as_AssignVariableOptions() const
9544   {
9545     return builtin_options_type() == onert_tflite::BuiltinOptions_AssignVariableOptions
9546              ? static_cast<const onert_tflite::AssignVariableOptions *>(builtin_options())
9547              : nullptr;
9548   }
9549   const onert_tflite::RandomOptions *builtin_options_as_RandomOptions() const
9550   {
9551     return builtin_options_type() == onert_tflite::BuiltinOptions_RandomOptions
9552              ? static_cast<const onert_tflite::RandomOptions *>(builtin_options())
9553              : nullptr;
9554   }
9555   const onert_tflite::BucketizeOptions *builtin_options_as_BucketizeOptions() const
9556   {
9557     return builtin_options_type() == onert_tflite::BuiltinOptions_BucketizeOptions
9558              ? static_cast<const onert_tflite::BucketizeOptions *>(builtin_options())
9559              : nullptr;
9560   }
9561   const onert_tflite::GeluOptions *builtin_options_as_GeluOptions() const
9562   {
9563     return builtin_options_type() == onert_tflite::BuiltinOptions_GeluOptions
9564              ? static_cast<const onert_tflite::GeluOptions *>(builtin_options())
9565              : nullptr;
9566   }
9567   const onert_tflite::DynamicUpdateSliceOptions *
9568   builtin_options_as_DynamicUpdateSliceOptions() const
9569   {
9570     return builtin_options_type() == onert_tflite::BuiltinOptions_DynamicUpdateSliceOptions
9571              ? static_cast<const onert_tflite::DynamicUpdateSliceOptions *>(builtin_options())
9572              : nullptr;
9573   }
9574   const onert_tflite::UnsortedSegmentProdOptions *
9575   builtin_options_as_UnsortedSegmentProdOptions() const
9576   {
9577     return builtin_options_type() == onert_tflite::BuiltinOptions_UnsortedSegmentProdOptions
9578              ? static_cast<const onert_tflite::UnsortedSegmentProdOptions *>(builtin_options())
9579              : nullptr;
9580   }
9581   const onert_tflite::UnsortedSegmentMaxOptions *
9582   builtin_options_as_UnsortedSegmentMaxOptions() const
9583   {
9584     return builtin_options_type() == onert_tflite::BuiltinOptions_UnsortedSegmentMaxOptions
9585              ? static_cast<const onert_tflite::UnsortedSegmentMaxOptions *>(builtin_options())
9586              : nullptr;
9587   }
9588   const onert_tflite::UnsortedSegmentSumOptions *
9589   builtin_options_as_UnsortedSegmentSumOptions() const
9590   {
9591     return builtin_options_type() == onert_tflite::BuiltinOptions_UnsortedSegmentSumOptions
9592              ? static_cast<const onert_tflite::UnsortedSegmentSumOptions *>(builtin_options())
9593              : nullptr;
9594   }
9595   const onert_tflite::ATan2Options *builtin_options_as_ATan2Options() const
9596   {
9597     return builtin_options_type() == onert_tflite::BuiltinOptions_ATan2Options
9598              ? static_cast<const onert_tflite::ATan2Options *>(builtin_options())
9599              : nullptr;
9600   }
9601   const flatbuffers::Vector<uint8_t> *custom_options() const
9602   {
9603     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
9604   }
9605   onert_tflite::CustomOptionsFormat custom_options_format() const
9606   {
9607     return static_cast<onert_tflite::CustomOptionsFormat>(
9608       GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
9609   }
9610   const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const
9611   {
9612     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
9613   }
9614   const flatbuffers::Vector<int32_t> *intermediates() const
9615   {
9616     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
9617   }
9618   bool Verify(flatbuffers::Verifier &verifier) const
9619   {
9620     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
9621            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
9622            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
9623            VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
9624            VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
9625            VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
9626            VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && verifier.VerifyVector(custom_options()) &&
9627            VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
9628            VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
9629            verifier.VerifyVector(mutating_variable_inputs()) &&
9630            VerifyOffset(verifier, VT_INTERMEDIATES) && verifier.VerifyVector(intermediates()) &&
9631            verifier.EndTable();
9632   }
9633 };
9634
9635 template <>
9636 inline const onert_tflite::Conv2DOptions *
9637 Operator::builtin_options_as<onert_tflite::Conv2DOptions>() const
9638 {
9639   return builtin_options_as_Conv2DOptions();
9640 }
9641
9642 template <>
9643 inline const onert_tflite::DepthwiseConv2DOptions *
9644 Operator::builtin_options_as<onert_tflite::DepthwiseConv2DOptions>() const
9645 {
9646   return builtin_options_as_DepthwiseConv2DOptions();
9647 }
9648
9649 template <>
9650 inline const onert_tflite::ConcatEmbeddingsOptions *
9651 Operator::builtin_options_as<onert_tflite::ConcatEmbeddingsOptions>() const
9652 {
9653   return builtin_options_as_ConcatEmbeddingsOptions();
9654 }
9655
9656 template <>
9657 inline const onert_tflite::LSHProjectionOptions *
9658 Operator::builtin_options_as<onert_tflite::LSHProjectionOptions>() const
9659 {
9660   return builtin_options_as_LSHProjectionOptions();
9661 }
9662
9663 template <>
9664 inline const onert_tflite::Pool2DOptions *
9665 Operator::builtin_options_as<onert_tflite::Pool2DOptions>() const
9666 {
9667   return builtin_options_as_Pool2DOptions();
9668 }
9669
9670 template <>
9671 inline const onert_tflite::SVDFOptions *
9672 Operator::builtin_options_as<onert_tflite::SVDFOptions>() const
9673 {
9674   return builtin_options_as_SVDFOptions();
9675 }
9676
9677 template <>
9678 inline const onert_tflite::RNNOptions *
9679 Operator::builtin_options_as<onert_tflite::RNNOptions>() const
9680 {
9681   return builtin_options_as_RNNOptions();
9682 }
9683
9684 template <>
9685 inline const onert_tflite::FullyConnectedOptions *
9686 Operator::builtin_options_as<onert_tflite::FullyConnectedOptions>() const
9687 {
9688   return builtin_options_as_FullyConnectedOptions();
9689 }
9690
9691 template <>
9692 inline const onert_tflite::SoftmaxOptions *
9693 Operator::builtin_options_as<onert_tflite::SoftmaxOptions>() const
9694 {
9695   return builtin_options_as_SoftmaxOptions();
9696 }
9697
9698 template <>
9699 inline const onert_tflite::ConcatenationOptions *
9700 Operator::builtin_options_as<onert_tflite::ConcatenationOptions>() const
9701 {
9702   return builtin_options_as_ConcatenationOptions();
9703 }
9704
9705 template <>
9706 inline const onert_tflite::AddOptions *
9707 Operator::builtin_options_as<onert_tflite::AddOptions>() const
9708 {
9709   return builtin_options_as_AddOptions();
9710 }
9711
9712 template <>
9713 inline const onert_tflite::L2NormOptions *
9714 Operator::builtin_options_as<onert_tflite::L2NormOptions>() const
9715 {
9716   return builtin_options_as_L2NormOptions();
9717 }
9718
9719 template <>
9720 inline const onert_tflite::LocalResponseNormalizationOptions *
9721 Operator::builtin_options_as<onert_tflite::LocalResponseNormalizationOptions>() const
9722 {
9723   return builtin_options_as_LocalResponseNormalizationOptions();
9724 }
9725
9726 template <>
9727 inline const onert_tflite::LSTMOptions *
9728 Operator::builtin_options_as<onert_tflite::LSTMOptions>() const
9729 {
9730   return builtin_options_as_LSTMOptions();
9731 }
9732
9733 template <>
9734 inline const onert_tflite::ResizeBilinearOptions *
9735 Operator::builtin_options_as<onert_tflite::ResizeBilinearOptions>() const
9736 {
9737   return builtin_options_as_ResizeBilinearOptions();
9738 }
9739
9740 template <>
9741 inline const onert_tflite::CallOptions *
9742 Operator::builtin_options_as<onert_tflite::CallOptions>() const
9743 {
9744   return builtin_options_as_CallOptions();
9745 }
9746
9747 template <>
9748 inline const onert_tflite::ReshapeOptions *
9749 Operator::builtin_options_as<onert_tflite::ReshapeOptions>() const
9750 {
9751   return builtin_options_as_ReshapeOptions();
9752 }
9753
9754 template <>
9755 inline const onert_tflite::SkipGramOptions *
9756 Operator::builtin_options_as<onert_tflite::SkipGramOptions>() const
9757 {
9758   return builtin_options_as_SkipGramOptions();
9759 }
9760
9761 template <>
9762 inline const onert_tflite::SpaceToDepthOptions *
9763 Operator::builtin_options_as<onert_tflite::SpaceToDepthOptions>() const
9764 {
9765   return builtin_options_as_SpaceToDepthOptions();
9766 }
9767
9768 template <>
9769 inline const onert_tflite::EmbeddingLookupSparseOptions *
9770 Operator::builtin_options_as<onert_tflite::EmbeddingLookupSparseOptions>() const
9771 {
9772   return builtin_options_as_EmbeddingLookupSparseOptions();
9773 }
9774
9775 template <>
9776 inline const onert_tflite::MulOptions *
9777 Operator::builtin_options_as<onert_tflite::MulOptions>() const
9778 {
9779   return builtin_options_as_MulOptions();
9780 }
9781
9782 template <>
9783 inline const onert_tflite::PadOptions *
9784 Operator::builtin_options_as<onert_tflite::PadOptions>() const
9785 {
9786   return builtin_options_as_PadOptions();
9787 }
9788
9789 template <>
9790 inline const onert_tflite::GatherOptions *
9791 Operator::builtin_options_as<onert_tflite::GatherOptions>() const
9792 {
9793   return builtin_options_as_GatherOptions();
9794 }
9795
9796 template <>
9797 inline const onert_tflite::BatchToSpaceNDOptions *
9798 Operator::builtin_options_as<onert_tflite::BatchToSpaceNDOptions>() const
9799 {
9800   return builtin_options_as_BatchToSpaceNDOptions();
9801 }
9802
9803 template <>
9804 inline const onert_tflite::SpaceToBatchNDOptions *
9805 Operator::builtin_options_as<onert_tflite::SpaceToBatchNDOptions>() const
9806 {
9807   return builtin_options_as_SpaceToBatchNDOptions();
9808 }
9809
9810 template <>
9811 inline const onert_tflite::TransposeOptions *
9812 Operator::builtin_options_as<onert_tflite::TransposeOptions>() const
9813 {
9814   return builtin_options_as_TransposeOptions();
9815 }
9816
9817 template <>
9818 inline const onert_tflite::ReducerOptions *
9819 Operator::builtin_options_as<onert_tflite::ReducerOptions>() const
9820 {
9821   return builtin_options_as_ReducerOptions();
9822 }
9823
9824 template <>
9825 inline const onert_tflite::SubOptions *
9826 Operator::builtin_options_as<onert_tflite::SubOptions>() const
9827 {
9828   return builtin_options_as_SubOptions();
9829 }
9830
9831 template <>
9832 inline const onert_tflite::DivOptions *
9833 Operator::builtin_options_as<onert_tflite::DivOptions>() const
9834 {
9835   return builtin_options_as_DivOptions();
9836 }
9837
9838 template <>
9839 inline const onert_tflite::SqueezeOptions *
9840 Operator::builtin_options_as<onert_tflite::SqueezeOptions>() const
9841 {
9842   return builtin_options_as_SqueezeOptions();
9843 }
9844
9845 template <>
9846 inline const onert_tflite::SequenceRNNOptions *
9847 Operator::builtin_options_as<onert_tflite::SequenceRNNOptions>() const
9848 {
9849   return builtin_options_as_SequenceRNNOptions();
9850 }
9851
9852 template <>
9853 inline const onert_tflite::StridedSliceOptions *
9854 Operator::builtin_options_as<onert_tflite::StridedSliceOptions>() const
9855 {
9856   return builtin_options_as_StridedSliceOptions();
9857 }
9858
9859 template <>
9860 inline const onert_tflite::ExpOptions *
9861 Operator::builtin_options_as<onert_tflite::ExpOptions>() const
9862 {
9863   return builtin_options_as_ExpOptions();
9864 }
9865
9866 template <>
9867 inline const onert_tflite::TopKV2Options *
9868 Operator::builtin_options_as<onert_tflite::TopKV2Options>() const
9869 {
9870   return builtin_options_as_TopKV2Options();
9871 }
9872
9873 template <>
9874 inline const onert_tflite::SplitOptions *
9875 Operator::builtin_options_as<onert_tflite::SplitOptions>() const
9876 {
9877   return builtin_options_as_SplitOptions();
9878 }
9879
9880 template <>
9881 inline const onert_tflite::LogSoftmaxOptions *
9882 Operator::builtin_options_as<onert_tflite::LogSoftmaxOptions>() const
9883 {
9884   return builtin_options_as_LogSoftmaxOptions();
9885 }
9886
9887 template <>
9888 inline const onert_tflite::CastOptions *
9889 Operator::builtin_options_as<onert_tflite::CastOptions>() const
9890 {
9891   return builtin_options_as_CastOptions();
9892 }
9893
9894 template <>
9895 inline const onert_tflite::DequantizeOptions *
9896 Operator::builtin_options_as<onert_tflite::DequantizeOptions>() const
9897 {
9898   return builtin_options_as_DequantizeOptions();
9899 }
9900
9901 template <>
9902 inline const onert_tflite::MaximumMinimumOptions *
9903 Operator::builtin_options_as<onert_tflite::MaximumMinimumOptions>() const
9904 {
9905   return builtin_options_as_MaximumMinimumOptions();
9906 }
9907
9908 template <>
9909 inline const onert_tflite::ArgMaxOptions *
9910 Operator::builtin_options_as<onert_tflite::ArgMaxOptions>() const
9911 {
9912   return builtin_options_as_ArgMaxOptions();
9913 }
9914
9915 template <>
9916 inline const onert_tflite::LessOptions *
9917 Operator::builtin_options_as<onert_tflite::LessOptions>() const
9918 {
9919   return builtin_options_as_LessOptions();
9920 }
9921
9922 template <>
9923 inline const onert_tflite::NegOptions *
9924 Operator::builtin_options_as<onert_tflite::NegOptions>() const
9925 {
9926   return builtin_options_as_NegOptions();
9927 }
9928
9929 template <>
9930 inline const onert_tflite::PadV2Options *
9931 Operator::builtin_options_as<onert_tflite::PadV2Options>() const
9932 {
9933   return builtin_options_as_PadV2Options();
9934 }
9935
9936 template <>
9937 inline const onert_tflite::GreaterOptions *
9938 Operator::builtin_options_as<onert_tflite::GreaterOptions>() const
9939 {
9940   return builtin_options_as_GreaterOptions();
9941 }
9942
9943 template <>
9944 inline const onert_tflite::GreaterEqualOptions *
9945 Operator::builtin_options_as<onert_tflite::GreaterEqualOptions>() const
9946 {
9947   return builtin_options_as_GreaterEqualOptions();
9948 }
9949
9950 template <>
9951 inline const onert_tflite::LessEqualOptions *
9952 Operator::builtin_options_as<onert_tflite::LessEqualOptions>() const
9953 {
9954   return builtin_options_as_LessEqualOptions();
9955 }
9956
9957 template <>
9958 inline const onert_tflite::SelectOptions *
9959 Operator::builtin_options_as<onert_tflite::SelectOptions>() const
9960 {
9961   return builtin_options_as_SelectOptions();
9962 }
9963
9964 template <>
9965 inline const onert_tflite::SliceOptions *
9966 Operator::builtin_options_as<onert_tflite::SliceOptions>() const
9967 {
9968   return builtin_options_as_SliceOptions();
9969 }
9970
9971 template <>
9972 inline const onert_tflite::TransposeConvOptions *
9973 Operator::builtin_options_as<onert_tflite::TransposeConvOptions>() const
9974 {
9975   return builtin_options_as_TransposeConvOptions();
9976 }
9977
9978 template <>
9979 inline const onert_tflite::SparseToDenseOptions *
9980 Operator::builtin_options_as<onert_tflite::SparseToDenseOptions>() const
9981 {
9982   return builtin_options_as_SparseToDenseOptions();
9983 }
9984
9985 template <>
9986 inline const onert_tflite::TileOptions *
9987 Operator::builtin_options_as<onert_tflite::TileOptions>() const
9988 {
9989   return builtin_options_as_TileOptions();
9990 }
9991
9992 template <>
9993 inline const onert_tflite::ExpandDimsOptions *
9994 Operator::builtin_options_as<onert_tflite::ExpandDimsOptions>() const
9995 {
9996   return builtin_options_as_ExpandDimsOptions();
9997 }
9998
9999 template <>
10000 inline const onert_tflite::EqualOptions *
10001 Operator::builtin_options_as<onert_tflite::EqualOptions>() const
10002 {
10003   return builtin_options_as_EqualOptions();
10004 }
10005
10006 template <>
10007 inline const onert_tflite::NotEqualOptions *
10008 Operator::builtin_options_as<onert_tflite::NotEqualOptions>() const
10009 {
10010   return builtin_options_as_NotEqualOptions();
10011 }
10012
10013 template <>
10014 inline const onert_tflite::ShapeOptions *
10015 Operator::builtin_options_as<onert_tflite::ShapeOptions>() const
10016 {
10017   return builtin_options_as_ShapeOptions();
10018 }
10019
10020 template <>
10021 inline const onert_tflite::PowOptions *
10022 Operator::builtin_options_as<onert_tflite::PowOptions>() const
10023 {
10024   return builtin_options_as_PowOptions();
10025 }
10026
10027 template <>
10028 inline const onert_tflite::ArgMinOptions *
10029 Operator::builtin_options_as<onert_tflite::ArgMinOptions>() const
10030 {
10031   return builtin_options_as_ArgMinOptions();
10032 }
10033
10034 template <>
10035 inline const onert_tflite::FakeQuantOptions *
10036 Operator::builtin_options_as<onert_tflite::FakeQuantOptions>() const
10037 {
10038   return builtin_options_as_FakeQuantOptions();
10039 }
10040
10041 template <>
10042 inline const onert_tflite::PackOptions *
10043 Operator::builtin_options_as<onert_tflite::PackOptions>() const
10044 {
10045   return builtin_options_as_PackOptions();
10046 }
10047
10048 template <>
10049 inline const onert_tflite::LogicalOrOptions *
10050 Operator::builtin_options_as<onert_tflite::LogicalOrOptions>() const
10051 {
10052   return builtin_options_as_LogicalOrOptions();
10053 }
10054
10055 template <>
10056 inline const onert_tflite::OneHotOptions *
10057 Operator::builtin_options_as<onert_tflite::OneHotOptions>() const
10058 {
10059   return builtin_options_as_OneHotOptions();
10060 }
10061
10062 template <>
10063 inline const onert_tflite::LogicalAndOptions *
10064 Operator::builtin_options_as<onert_tflite::LogicalAndOptions>() const
10065 {
10066   return builtin_options_as_LogicalAndOptions();
10067 }
10068
10069 template <>
10070 inline const onert_tflite::LogicalNotOptions *
10071 Operator::builtin_options_as<onert_tflite::LogicalNotOptions>() const
10072 {
10073   return builtin_options_as_LogicalNotOptions();
10074 }
10075
10076 template <>
10077 inline const onert_tflite::UnpackOptions *
10078 Operator::builtin_options_as<onert_tflite::UnpackOptions>() const
10079 {
10080   return builtin_options_as_UnpackOptions();
10081 }
10082
10083 template <>
10084 inline const onert_tflite::FloorDivOptions *
10085 Operator::builtin_options_as<onert_tflite::FloorDivOptions>() const
10086 {
10087   return builtin_options_as_FloorDivOptions();
10088 }
10089
10090 template <>
10091 inline const onert_tflite::SquareOptions *
10092 Operator::builtin_options_as<onert_tflite::SquareOptions>() const
10093 {
10094   return builtin_options_as_SquareOptions();
10095 }
10096
10097 template <>
10098 inline const onert_tflite::ZerosLikeOptions *
10099 Operator::builtin_options_as<onert_tflite::ZerosLikeOptions>() const
10100 {
10101   return builtin_options_as_ZerosLikeOptions();
10102 }
10103
10104 template <>
10105 inline const onert_tflite::FillOptions *
10106 Operator::builtin_options_as<onert_tflite::FillOptions>() const
10107 {
10108   return builtin_options_as_FillOptions();
10109 }
10110
10111 template <>
10112 inline const onert_tflite::BidirectionalSequenceLSTMOptions *
10113 Operator::builtin_options_as<onert_tflite::BidirectionalSequenceLSTMOptions>() const
10114 {
10115   return builtin_options_as_BidirectionalSequenceLSTMOptions();
10116 }
10117
10118 template <>
10119 inline const onert_tflite::BidirectionalSequenceRNNOptions *
10120 Operator::builtin_options_as<onert_tflite::BidirectionalSequenceRNNOptions>() const
10121 {
10122   return builtin_options_as_BidirectionalSequenceRNNOptions();
10123 }
10124
10125 template <>
10126 inline const onert_tflite::UnidirectionalSequenceLSTMOptions *
10127 Operator::builtin_options_as<onert_tflite::UnidirectionalSequenceLSTMOptions>() const
10128 {
10129   return builtin_options_as_UnidirectionalSequenceLSTMOptions();
10130 }
10131
10132 template <>
10133 inline const onert_tflite::FloorModOptions *
10134 Operator::builtin_options_as<onert_tflite::FloorModOptions>() const
10135 {
10136   return builtin_options_as_FloorModOptions();
10137 }
10138
10139 template <>
10140 inline const onert_tflite::RangeOptions *
10141 Operator::builtin_options_as<onert_tflite::RangeOptions>() const
10142 {
10143   return builtin_options_as_RangeOptions();
10144 }
10145
10146 template <>
10147 inline const onert_tflite::ResizeNearestNeighborOptions *
10148 Operator::builtin_options_as<onert_tflite::ResizeNearestNeighborOptions>() const
10149 {
10150   return builtin_options_as_ResizeNearestNeighborOptions();
10151 }
10152
10153 template <>
10154 inline const onert_tflite::LeakyReluOptions *
10155 Operator::builtin_options_as<onert_tflite::LeakyReluOptions>() const
10156 {
10157   return builtin_options_as_LeakyReluOptions();
10158 }
10159
10160 template <>
10161 inline const onert_tflite::SquaredDifferenceOptions *
10162 Operator::builtin_options_as<onert_tflite::SquaredDifferenceOptions>() const
10163 {
10164   return builtin_options_as_SquaredDifferenceOptions();
10165 }
10166
10167 template <>
10168 inline const onert_tflite::MirrorPadOptions *
10169 Operator::builtin_options_as<onert_tflite::MirrorPadOptions>() const
10170 {
10171   return builtin_options_as_MirrorPadOptions();
10172 }
10173
10174 template <>
10175 inline const onert_tflite::AbsOptions *
10176 Operator::builtin_options_as<onert_tflite::AbsOptions>() const
10177 {
10178   return builtin_options_as_AbsOptions();
10179 }
10180
10181 template <>
10182 inline const onert_tflite::SplitVOptions *
10183 Operator::builtin_options_as<onert_tflite::SplitVOptions>() const
10184 {
10185   return builtin_options_as_SplitVOptions();
10186 }
10187
10188 template <>
10189 inline const onert_tflite::UniqueOptions *
10190 Operator::builtin_options_as<onert_tflite::UniqueOptions>() const
10191 {
10192   return builtin_options_as_UniqueOptions();
10193 }
10194
10195 template <>
10196 inline const onert_tflite::ReverseV2Options *
10197 Operator::builtin_options_as<onert_tflite::ReverseV2Options>() const
10198 {
10199   return builtin_options_as_ReverseV2Options();
10200 }
10201
10202 template <>
10203 inline const onert_tflite::AddNOptions *
10204 Operator::builtin_options_as<onert_tflite::AddNOptions>() const
10205 {
10206   return builtin_options_as_AddNOptions();
10207 }
10208
10209 template <>
10210 inline const onert_tflite::GatherNdOptions *
10211 Operator::builtin_options_as<onert_tflite::GatherNdOptions>() const
10212 {
10213   return builtin_options_as_GatherNdOptions();
10214 }
10215
10216 template <>
10217 inline const onert_tflite::CosOptions *
10218 Operator::builtin_options_as<onert_tflite::CosOptions>() const
10219 {
10220   return builtin_options_as_CosOptions();
10221 }
10222
10223 template <>
10224 inline const onert_tflite::WhereOptions *
10225 Operator::builtin_options_as<onert_tflite::WhereOptions>() const
10226 {
10227   return builtin_options_as_WhereOptions();
10228 }
10229
10230 template <>
10231 inline const onert_tflite::RankOptions *
10232 Operator::builtin_options_as<onert_tflite::RankOptions>() const
10233 {
10234   return builtin_options_as_RankOptions();
10235 }
10236
10237 template <>
10238 inline const onert_tflite::ReverseSequenceOptions *
10239 Operator::builtin_options_as<onert_tflite::ReverseSequenceOptions>() const
10240 {
10241   return builtin_options_as_ReverseSequenceOptions();
10242 }
10243
10244 template <>
10245 inline const onert_tflite::MatrixDiagOptions *
10246 Operator::builtin_options_as<onert_tflite::MatrixDiagOptions>() const
10247 {
10248   return builtin_options_as_MatrixDiagOptions();
10249 }
10250
10251 template <>
10252 inline const onert_tflite::QuantizeOptions *
10253 Operator::builtin_options_as<onert_tflite::QuantizeOptions>() const
10254 {
10255   return builtin_options_as_QuantizeOptions();
10256 }
10257
10258 template <>
10259 inline const onert_tflite::MatrixSetDiagOptions *
10260 Operator::builtin_options_as<onert_tflite::MatrixSetDiagOptions>() const
10261 {
10262   return builtin_options_as_MatrixSetDiagOptions();
10263 }
10264
10265 template <>
10266 inline const onert_tflite::HardSwishOptions *
10267 Operator::builtin_options_as<onert_tflite::HardSwishOptions>() const
10268 {
10269   return builtin_options_as_HardSwishOptions();
10270 }
10271
10272 template <>
10273 inline const onert_tflite::IfOptions *Operator::builtin_options_as<onert_tflite::IfOptions>() const
10274 {
10275   return builtin_options_as_IfOptions();
10276 }
10277
10278 template <>
10279 inline const onert_tflite::WhileOptions *
10280 Operator::builtin_options_as<onert_tflite::WhileOptions>() const
10281 {
10282   return builtin_options_as_WhileOptions();
10283 }
10284
10285 template <>
10286 inline const onert_tflite::DepthToSpaceOptions *
10287 Operator::builtin_options_as<onert_tflite::DepthToSpaceOptions>() const
10288 {
10289   return builtin_options_as_DepthToSpaceOptions();
10290 }
10291
10292 template <>
10293 inline const onert_tflite::NonMaxSuppressionV4Options *
10294 Operator::builtin_options_as<onert_tflite::NonMaxSuppressionV4Options>() const
10295 {
10296   return builtin_options_as_NonMaxSuppressionV4Options();
10297 }
10298
10299 template <>
10300 inline const onert_tflite::NonMaxSuppressionV5Options *
10301 Operator::builtin_options_as<onert_tflite::NonMaxSuppressionV5Options>() const
10302 {
10303   return builtin_options_as_NonMaxSuppressionV5Options();
10304 }
10305
10306 template <>
10307 inline const onert_tflite::ScatterNdOptions *
10308 Operator::builtin_options_as<onert_tflite::ScatterNdOptions>() const
10309 {
10310   return builtin_options_as_ScatterNdOptions();
10311 }
10312
10313 template <>
10314 inline const onert_tflite::SelectV2Options *
10315 Operator::builtin_options_as<onert_tflite::SelectV2Options>() const
10316 {
10317   return builtin_options_as_SelectV2Options();
10318 }
10319
10320 template <>
10321 inline const onert_tflite::DensifyOptions *
10322 Operator::builtin_options_as<onert_tflite::DensifyOptions>() const
10323 {
10324   return builtin_options_as_DensifyOptions();
10325 }
10326
10327 template <>
10328 inline const onert_tflite::SegmentSumOptions *
10329 Operator::builtin_options_as<onert_tflite::SegmentSumOptions>() const
10330 {
10331   return builtin_options_as_SegmentSumOptions();
10332 }
10333
10334 template <>
10335 inline const onert_tflite::BatchMatMulOptions *
10336 Operator::builtin_options_as<onert_tflite::BatchMatMulOptions>() const
10337 {
10338   return builtin_options_as_BatchMatMulOptions();
10339 }
10340
10341 template <>
10342 inline const onert_tflite::CumsumOptions *
10343 Operator::builtin_options_as<onert_tflite::CumsumOptions>() const
10344 {
10345   return builtin_options_as_CumsumOptions();
10346 }
10347
10348 template <>
10349 inline const onert_tflite::CallOnceOptions *
10350 Operator::builtin_options_as<onert_tflite::CallOnceOptions>() const
10351 {
10352   return builtin_options_as_CallOnceOptions();
10353 }
10354
10355 template <>
10356 inline const onert_tflite::BroadcastToOptions *
10357 Operator::builtin_options_as<onert_tflite::BroadcastToOptions>() const
10358 {
10359   return builtin_options_as_BroadcastToOptions();
10360 }
10361
10362 template <>
10363 inline const onert_tflite::Rfft2dOptions *
10364 Operator::builtin_options_as<onert_tflite::Rfft2dOptions>() const
10365 {
10366   return builtin_options_as_Rfft2dOptions();
10367 }
10368
10369 template <>
10370 inline const onert_tflite::Conv3DOptions *
10371 Operator::builtin_options_as<onert_tflite::Conv3DOptions>() const
10372 {
10373   return builtin_options_as_Conv3DOptions();
10374 }
10375
10376 template <>
10377 inline const onert_tflite::HashtableOptions *
10378 Operator::builtin_options_as<onert_tflite::HashtableOptions>() const
10379 {
10380   return builtin_options_as_HashtableOptions();
10381 }
10382
10383 template <>
10384 inline const onert_tflite::HashtableFindOptions *
10385 Operator::builtin_options_as<onert_tflite::HashtableFindOptions>() const
10386 {
10387   return builtin_options_as_HashtableFindOptions();
10388 }
10389
10390 template <>
10391 inline const onert_tflite::HashtableImportOptions *
10392 Operator::builtin_options_as<onert_tflite::HashtableImportOptions>() const
10393 {
10394   return builtin_options_as_HashtableImportOptions();
10395 }
10396
10397 template <>
10398 inline const onert_tflite::HashtableSizeOptions *
10399 Operator::builtin_options_as<onert_tflite::HashtableSizeOptions>() const
10400 {
10401   return builtin_options_as_HashtableSizeOptions();
10402 }
10403
10404 template <>
10405 inline const onert_tflite::VarHandleOptions *
10406 Operator::builtin_options_as<onert_tflite::VarHandleOptions>() const
10407 {
10408   return builtin_options_as_VarHandleOptions();
10409 }
10410
10411 template <>
10412 inline const onert_tflite::ReadVariableOptions *
10413 Operator::builtin_options_as<onert_tflite::ReadVariableOptions>() const
10414 {
10415   return builtin_options_as_ReadVariableOptions();
10416 }
10417
10418 template <>
10419 inline const onert_tflite::AssignVariableOptions *
10420 Operator::builtin_options_as<onert_tflite::AssignVariableOptions>() const
10421 {
10422   return builtin_options_as_AssignVariableOptions();
10423 }
10424
10425 template <>
10426 inline const onert_tflite::RandomOptions *
10427 Operator::builtin_options_as<onert_tflite::RandomOptions>() const
10428 {
10429   return builtin_options_as_RandomOptions();
10430 }
10431
10432 template <>
10433 inline const onert_tflite::BucketizeOptions *
10434 Operator::builtin_options_as<onert_tflite::BucketizeOptions>() const
10435 {
10436   return builtin_options_as_BucketizeOptions();
10437 }
10438
10439 template <>
10440 inline const onert_tflite::GeluOptions *
10441 Operator::builtin_options_as<onert_tflite::GeluOptions>() const
10442 {
10443   return builtin_options_as_GeluOptions();
10444 }
10445
10446 template <>
10447 inline const onert_tflite::DynamicUpdateSliceOptions *
10448 Operator::builtin_options_as<onert_tflite::DynamicUpdateSliceOptions>() const
10449 {
10450   return builtin_options_as_DynamicUpdateSliceOptions();
10451 }
10452
10453 template <>
10454 inline const onert_tflite::UnsortedSegmentProdOptions *
10455 Operator::builtin_options_as<onert_tflite::UnsortedSegmentProdOptions>() const
10456 {
10457   return builtin_options_as_UnsortedSegmentProdOptions();
10458 }
10459
10460 template <>
10461 inline const onert_tflite::UnsortedSegmentMaxOptions *
10462 Operator::builtin_options_as<onert_tflite::UnsortedSegmentMaxOptions>() const
10463 {
10464   return builtin_options_as_UnsortedSegmentMaxOptions();
10465 }
10466
10467 template <>
10468 inline const onert_tflite::UnsortedSegmentSumOptions *
10469 Operator::builtin_options_as<onert_tflite::UnsortedSegmentSumOptions>() const
10470 {
10471   return builtin_options_as_UnsortedSegmentSumOptions();
10472 }
10473
10474 template <>
10475 inline const onert_tflite::ATan2Options *
10476 Operator::builtin_options_as<onert_tflite::ATan2Options>() const
10477 {
10478   return builtin_options_as_ATan2Options();
10479 }
10480
10481 struct OperatorBuilder
10482 {
10483   typedef Operator Table;
10484   flatbuffers::FlatBufferBuilder &fbb_;
10485   flatbuffers::uoffset_t start_;
10486   void add_opcode_index(uint32_t opcode_index)
10487   {
10488     fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
10489   }
10490   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
10491   {
10492     fbb_.AddOffset(Operator::VT_INPUTS, inputs);
10493   }
10494   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
10495   {
10496     fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
10497   }
10498   void add_builtin_options_type(onert_tflite::BuiltinOptions builtin_options_type)
10499   {
10500     fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE,
10501                              static_cast<uint8_t>(builtin_options_type), 0);
10502   }
10503   void add_builtin_options(flatbuffers::Offset<void> builtin_options)
10504   {
10505     fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
10506   }
10507   void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options)
10508   {
10509     fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
10510   }
10511   void add_custom_options_format(onert_tflite::CustomOptionsFormat custom_options_format)
10512   {
10513     fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT,
10514                             static_cast<int8_t>(custom_options_format), 0);
10515   }
10516   void add_mutating_variable_inputs(
10517     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs)
10518   {
10519     fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
10520   }
10521   void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates)
10522   {
10523     fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
10524   }
10525   explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10526   {
10527     start_ = fbb_.StartTable();
10528   }
10529   flatbuffers::Offset<Operator> Finish()
10530   {
10531     const auto end = fbb_.EndTable(start_);
10532     auto o = flatbuffers::Offset<Operator>(end);
10533     return o;
10534   }
10535 };
10536
10537 inline flatbuffers::Offset<Operator> CreateOperator(
10538   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
10539   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
10540   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
10541   onert_tflite::BuiltinOptions builtin_options_type = onert_tflite::BuiltinOptions_NONE,
10542   flatbuffers::Offset<void> builtin_options = 0,
10543   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
10544   onert_tflite::CustomOptionsFormat custom_options_format =
10545     onert_tflite::CustomOptionsFormat_FLEXBUFFERS,
10546   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
10547   flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0)
10548 {
10549   OperatorBuilder builder_(_fbb);
10550   builder_.add_intermediates(intermediates);
10551   builder_.add_mutating_variable_inputs(mutating_variable_inputs);
10552   builder_.add_custom_options(custom_options);
10553   builder_.add_builtin_options(builtin_options);
10554   builder_.add_outputs(outputs);
10555   builder_.add_inputs(inputs);
10556   builder_.add_opcode_index(opcode_index);
10557   builder_.add_custom_options_format(custom_options_format);
10558   builder_.add_builtin_options_type(builtin_options_type);
10559   return builder_.Finish();
10560 }
10561
10562 inline flatbuffers::Offset<Operator> CreateOperatorDirect(
10563   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
10564   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
10565   onert_tflite::BuiltinOptions builtin_options_type = onert_tflite::BuiltinOptions_NONE,
10566   flatbuffers::Offset<void> builtin_options = 0,
10567   const std::vector<uint8_t> *custom_options = nullptr,
10568   onert_tflite::CustomOptionsFormat custom_options_format =
10569     onert_tflite::CustomOptionsFormat_FLEXBUFFERS,
10570   const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
10571   const std::vector<int32_t> *intermediates = nullptr)
10572 {
10573   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
10574   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
10575   auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
10576   auto mutating_variable_inputs__ =
10577     mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
10578   auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
10579   return onert_tflite::CreateOperator(_fbb, opcode_index, inputs__, outputs__, builtin_options_type,
10580                                       builtin_options, custom_options__, custom_options_format,
10581                                       mutating_variable_inputs__, intermediates__);
10582 }
10583
10584 struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10585 {
10586   typedef SubGraphBuilder Builder;
10587   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10588   {
10589     VT_TENSORS = 4,
10590     VT_INPUTS = 6,
10591     VT_OUTPUTS = 8,
10592     VT_OPERATORS = 10,
10593     VT_NAME = 12
10594   };
10595   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Tensor>> *tensors() const
10596   {
10597     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Tensor>> *>(
10598       VT_TENSORS);
10599   }
10600   const flatbuffers::Vector<int32_t> *inputs() const
10601   {
10602     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
10603   }
10604   const flatbuffers::Vector<int32_t> *outputs() const
10605   {
10606     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
10607   }
10608   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Operator>> *operators() const
10609   {
10610     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Operator>> *>(
10611       VT_OPERATORS);
10612   }
10613   const flatbuffers::String *name() const
10614   {
10615     return GetPointer<const flatbuffers::String *>(VT_NAME);
10616   }
10617   bool Verify(flatbuffers::Verifier &verifier) const
10618   {
10619     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) &&
10620            verifier.VerifyVector(tensors()) && verifier.VerifyVectorOfTables(tensors()) &&
10621            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
10622            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
10623            VerifyOffset(verifier, VT_OPERATORS) && verifier.VerifyVector(operators()) &&
10624            verifier.VerifyVectorOfTables(operators()) && VerifyOffset(verifier, VT_NAME) &&
10625            verifier.VerifyString(name()) && verifier.EndTable();
10626   }
10627 };
10628
10629 struct SubGraphBuilder
10630 {
10631   typedef SubGraph Table;
10632   flatbuffers::FlatBufferBuilder &fbb_;
10633   flatbuffers::uoffset_t start_;
10634   void add_tensors(
10635     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Tensor>>> tensors)
10636   {
10637     fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
10638   }
10639   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
10640   {
10641     fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
10642   }
10643   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
10644   {
10645     fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
10646   }
10647   void add_operators(
10648     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Operator>>> operators)
10649   {
10650     fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
10651   }
10652   void add_name(flatbuffers::Offset<flatbuffers::String> name)
10653   {
10654     fbb_.AddOffset(SubGraph::VT_NAME, name);
10655   }
10656   explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10657   {
10658     start_ = fbb_.StartTable();
10659   }
10660   flatbuffers::Offset<SubGraph> Finish()
10661   {
10662     const auto end = fbb_.EndTable(start_);
10663     auto o = flatbuffers::Offset<SubGraph>(end);
10664     return o;
10665   }
10666 };
10667
10668 inline flatbuffers::Offset<SubGraph> CreateSubGraph(
10669   flatbuffers::FlatBufferBuilder &_fbb,
10670   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Tensor>>> tensors = 0,
10671   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
10672   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
10673   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Operator>>> operators =
10674     0,
10675   flatbuffers::Offset<flatbuffers::String> name = 0)
10676 {
10677   SubGraphBuilder builder_(_fbb);
10678   builder_.add_name(name);
10679   builder_.add_operators(operators);
10680   builder_.add_outputs(outputs);
10681   builder_.add_inputs(inputs);
10682   builder_.add_tensors(tensors);
10683   return builder_.Finish();
10684 }
10685
10686 inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
10687   flatbuffers::FlatBufferBuilder &_fbb,
10688   const std::vector<flatbuffers::Offset<onert_tflite::Tensor>> *tensors = nullptr,
10689   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
10690   const std::vector<flatbuffers::Offset<onert_tflite::Operator>> *operators = nullptr,
10691   const char *name = nullptr)
10692 {
10693   auto tensors__ =
10694     tensors ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::Tensor>>(*tensors) : 0;
10695   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
10696   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
10697   auto operators__ =
10698     operators ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::Operator>>(*operators) : 0;
10699   auto name__ = name ? _fbb.CreateString(name) : 0;
10700   return onert_tflite::CreateSubGraph(_fbb, tensors__, inputs__, outputs__, operators__, name__);
10701 }
10702
10703 struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10704 {
10705   typedef BufferBuilder Builder;
10706   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10707   {
10708     VT_DATA = 4
10709   };
10710   const flatbuffers::Vector<uint8_t> *data() const
10711   {
10712     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
10713   }
10714   bool Verify(flatbuffers::Verifier &verifier) const
10715   {
10716     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) &&
10717            verifier.VerifyVector(data()) && verifier.EndTable();
10718   }
10719 };
10720
10721 struct BufferBuilder
10722 {
10723   typedef Buffer Table;
10724   flatbuffers::FlatBufferBuilder &fbb_;
10725   flatbuffers::uoffset_t start_;
10726   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data)
10727   {
10728     fbb_.AddOffset(Buffer::VT_DATA, data);
10729   }
10730   explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10731   {
10732     start_ = fbb_.StartTable();
10733   }
10734   flatbuffers::Offset<Buffer> Finish()
10735   {
10736     const auto end = fbb_.EndTable(start_);
10737     auto o = flatbuffers::Offset<Buffer>(end);
10738     return o;
10739   }
10740 };
10741
10742 inline flatbuffers::Offset<Buffer>
10743 CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb,
10744              flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0)
10745 {
10746   BufferBuilder builder_(_fbb);
10747   builder_.add_data(data);
10748   return builder_.Finish();
10749 }
10750
10751 inline flatbuffers::Offset<Buffer> CreateBufferDirect(flatbuffers::FlatBufferBuilder &_fbb,
10752                                                       const std::vector<uint8_t> *data = nullptr)
10753 {
10754   if (data)
10755   {
10756     _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16);
10757   }
10758   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
10759   return onert_tflite::CreateBuffer(_fbb, data__);
10760 }
10761
10762 struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10763 {
10764   typedef MetadataBuilder Builder;
10765   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10766   {
10767     VT_NAME = 4,
10768     VT_BUFFER = 6
10769   };
10770   const flatbuffers::String *name() const
10771   {
10772     return GetPointer<const flatbuffers::String *>(VT_NAME);
10773   }
10774   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
10775   bool Verify(flatbuffers::Verifier &verifier) const
10776   {
10777     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
10778            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_BUFFER) &&
10779            verifier.EndTable();
10780   }
10781 };
10782
10783 struct MetadataBuilder
10784 {
10785   typedef Metadata Table;
10786   flatbuffers::FlatBufferBuilder &fbb_;
10787   flatbuffers::uoffset_t start_;
10788   void add_name(flatbuffers::Offset<flatbuffers::String> name)
10789   {
10790     fbb_.AddOffset(Metadata::VT_NAME, name);
10791   }
10792   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0); }
10793   explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10794   {
10795     start_ = fbb_.StartTable();
10796   }
10797   flatbuffers::Offset<Metadata> Finish()
10798   {
10799     const auto end = fbb_.EndTable(start_);
10800     auto o = flatbuffers::Offset<Metadata>(end);
10801     return o;
10802   }
10803 };
10804
10805 inline flatbuffers::Offset<Metadata>
10806 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb,
10807                flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t buffer = 0)
10808 {
10809   MetadataBuilder builder_(_fbb);
10810   builder_.add_buffer(buffer);
10811   builder_.add_name(name);
10812   return builder_.Finish();
10813 }
10814
10815 inline flatbuffers::Offset<Metadata> CreateMetadataDirect(flatbuffers::FlatBufferBuilder &_fbb,
10816                                                           const char *name = nullptr,
10817                                                           uint32_t buffer = 0)
10818 {
10819   auto name__ = name ? _fbb.CreateString(name) : 0;
10820   return onert_tflite::CreateMetadata(_fbb, name__, buffer);
10821 }
10822
10823 struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10824 {
10825   typedef TensorMapBuilder Builder;
10826   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10827   {
10828     VT_NAME = 4,
10829     VT_TENSOR_INDEX = 6
10830   };
10831   const flatbuffers::String *name() const
10832   {
10833     return GetPointer<const flatbuffers::String *>(VT_NAME);
10834   }
10835   uint32_t tensor_index() const { return GetField<uint32_t>(VT_TENSOR_INDEX, 0); }
10836   bool Verify(flatbuffers::Verifier &verifier) const
10837   {
10838     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
10839            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX) &&
10840            verifier.EndTable();
10841   }
10842 };
10843
10844 struct TensorMapBuilder
10845 {
10846   typedef TensorMap Table;
10847   flatbuffers::FlatBufferBuilder &fbb_;
10848   flatbuffers::uoffset_t start_;
10849   void add_name(flatbuffers::Offset<flatbuffers::String> name)
10850   {
10851     fbb_.AddOffset(TensorMap::VT_NAME, name);
10852   }
10853   void add_tensor_index(uint32_t tensor_index)
10854   {
10855     fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
10856   }
10857   explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10858   {
10859     start_ = fbb_.StartTable();
10860   }
10861   flatbuffers::Offset<TensorMap> Finish()
10862   {
10863     const auto end = fbb_.EndTable(start_);
10864     auto o = flatbuffers::Offset<TensorMap>(end);
10865     return o;
10866   }
10867 };
10868
10869 inline flatbuffers::Offset<TensorMap>
10870 CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb,
10871                 flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t tensor_index = 0)
10872 {
10873   TensorMapBuilder builder_(_fbb);
10874   builder_.add_tensor_index(tensor_index);
10875   builder_.add_name(name);
10876   return builder_.Finish();
10877 }
10878
10879 inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(flatbuffers::FlatBufferBuilder &_fbb,
10880                                                             const char *name = nullptr,
10881                                                             uint32_t tensor_index = 0)
10882 {
10883   auto name__ = name ? _fbb.CreateString(name) : 0;
10884   return onert_tflite::CreateTensorMap(_fbb, name__, tensor_index);
10885 }
10886
10887 struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10888 {
10889   typedef SignatureDefBuilder Builder;
10890   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10891   {
10892     VT_INPUTS = 4,
10893     VT_OUTPUTS = 6,
10894     VT_SIGNATURE_KEY = 8,
10895     VT_SUBGRAPH_INDEX = 12
10896   };
10897   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>> *inputs() const
10898   {
10899     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>> *>(
10900       VT_INPUTS);
10901   }
10902   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>> *outputs() const
10903   {
10904     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>> *>(
10905       VT_OUTPUTS);
10906   }
10907   const flatbuffers::String *signature_key() const
10908   {
10909     return GetPointer<const flatbuffers::String *>(VT_SIGNATURE_KEY);
10910   }
10911   uint32_t subgraph_index() const { return GetField<uint32_t>(VT_SUBGRAPH_INDEX, 0); }
10912   bool Verify(flatbuffers::Verifier &verifier) const
10913   {
10914     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INPUTS) &&
10915            verifier.VerifyVector(inputs()) && verifier.VerifyVectorOfTables(inputs()) &&
10916            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
10917            verifier.VerifyVectorOfTables(outputs()) && VerifyOffset(verifier, VT_SIGNATURE_KEY) &&
10918            verifier.VerifyString(signature_key()) &&
10919            VerifyField<uint32_t>(verifier, VT_SUBGRAPH_INDEX) && verifier.EndTable();
10920   }
10921 };
10922
10923 struct SignatureDefBuilder
10924 {
10925   typedef SignatureDef Table;
10926   flatbuffers::FlatBufferBuilder &fbb_;
10927   flatbuffers::uoffset_t start_;
10928   void add_inputs(
10929     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>>> inputs)
10930   {
10931     fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
10932   }
10933   void add_outputs(
10934     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>>> outputs)
10935   {
10936     fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
10937   }
10938   void add_signature_key(flatbuffers::Offset<flatbuffers::String> signature_key)
10939   {
10940     fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key);
10941   }
10942   void add_subgraph_index(uint32_t subgraph_index)
10943   {
10944     fbb_.AddElement<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0);
10945   }
10946   explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10947   {
10948     start_ = fbb_.StartTable();
10949   }
10950   flatbuffers::Offset<SignatureDef> Finish()
10951   {
10952     const auto end = fbb_.EndTable(start_);
10953     auto o = flatbuffers::Offset<SignatureDef>(end);
10954     return o;
10955   }
10956 };
10957
10958 inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
10959   flatbuffers::FlatBufferBuilder &_fbb,
10960   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>>> inputs = 0,
10961   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::TensorMap>>> outputs =
10962     0,
10963   flatbuffers::Offset<flatbuffers::String> signature_key = 0, uint32_t subgraph_index = 0)
10964 {
10965   SignatureDefBuilder builder_(_fbb);
10966   builder_.add_subgraph_index(subgraph_index);
10967   builder_.add_signature_key(signature_key);
10968   builder_.add_outputs(outputs);
10969   builder_.add_inputs(inputs);
10970   return builder_.Finish();
10971 }
10972
10973 inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
10974   flatbuffers::FlatBufferBuilder &_fbb,
10975   const std::vector<flatbuffers::Offset<onert_tflite::TensorMap>> *inputs = nullptr,
10976   const std::vector<flatbuffers::Offset<onert_tflite::TensorMap>> *outputs = nullptr,
10977   const char *signature_key = nullptr, uint32_t subgraph_index = 0)
10978 {
10979   auto inputs__ =
10980     inputs ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::TensorMap>>(*inputs) : 0;
10981   auto outputs__ =
10982     outputs ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::TensorMap>>(*outputs) : 0;
10983   auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0;
10984   return onert_tflite::CreateSignatureDef(_fbb, inputs__, outputs__, signature_key__,
10985                                           subgraph_index);
10986 }
10987
10988 struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10989 {
10990   typedef ModelBuilder Builder;
10991   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10992   {
10993     VT_VERSION = 4,
10994     VT_OPERATOR_CODES = 6,
10995     VT_SUBGRAPHS = 8,
10996     VT_DESCRIPTION = 10,
10997     VT_BUFFERS = 12,
10998     VT_METADATA_BUFFER = 14,
10999     VT_METADATA = 16,
11000     VT_SIGNATURE_DEFS = 18
11001   };
11002   uint32_t version() const { return GetField<uint32_t>(VT_VERSION, 0); }
11003   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::OperatorCode>> *operator_codes() const
11004   {
11005     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::OperatorCode>> *>(
11006       VT_OPERATOR_CODES);
11007   }
11008   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SubGraph>> *subgraphs() const
11009   {
11010     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SubGraph>> *>(
11011       VT_SUBGRAPHS);
11012   }
11013   const flatbuffers::String *description() const
11014   {
11015     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
11016   }
11017   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Buffer>> *buffers() const
11018   {
11019     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Buffer>> *>(
11020       VT_BUFFERS);
11021   }
11022   const flatbuffers::Vector<int32_t> *metadata_buffer() const
11023   {
11024     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
11025   }
11026   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Metadata>> *metadata() const
11027   {
11028     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Metadata>> *>(
11029       VT_METADATA);
11030   }
11031   const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SignatureDef>> *signature_defs() const
11032   {
11033     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SignatureDef>> *>(
11034       VT_SIGNATURE_DEFS);
11035   }
11036   bool Verify(flatbuffers::Verifier &verifier) const
11037   {
11038     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_VERSION) &&
11039            VerifyOffset(verifier, VT_OPERATOR_CODES) && verifier.VerifyVector(operator_codes()) &&
11040            verifier.VerifyVectorOfTables(operator_codes()) &&
11041            VerifyOffset(verifier, VT_SUBGRAPHS) && verifier.VerifyVector(subgraphs()) &&
11042            verifier.VerifyVectorOfTables(subgraphs()) && VerifyOffset(verifier, VT_DESCRIPTION) &&
11043            verifier.VerifyString(description()) && VerifyOffset(verifier, VT_BUFFERS) &&
11044            verifier.VerifyVector(buffers()) && verifier.VerifyVectorOfTables(buffers()) &&
11045            VerifyOffset(verifier, VT_METADATA_BUFFER) && verifier.VerifyVector(metadata_buffer()) &&
11046            VerifyOffset(verifier, VT_METADATA) && verifier.VerifyVector(metadata()) &&
11047            verifier.VerifyVectorOfTables(metadata()) && VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
11048            verifier.VerifyVector(signature_defs()) &&
11049            verifier.VerifyVectorOfTables(signature_defs()) && verifier.EndTable();
11050   }
11051 };
11052
11053 struct ModelBuilder
11054 {
11055   typedef Model Table;
11056   flatbuffers::FlatBufferBuilder &fbb_;
11057   flatbuffers::uoffset_t start_;
11058   void add_version(uint32_t version) { fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0); }
11059   void add_operator_codes(
11060     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::OperatorCode>>>
11061       operator_codes)
11062   {
11063     fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
11064   }
11065   void add_subgraphs(
11066     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SubGraph>>> subgraphs)
11067   {
11068     fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
11069   }
11070   void add_description(flatbuffers::Offset<flatbuffers::String> description)
11071   {
11072     fbb_.AddOffset(Model::VT_DESCRIPTION, description);
11073   }
11074   void add_buffers(
11075     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Buffer>>> buffers)
11076   {
11077     fbb_.AddOffset(Model::VT_BUFFERS, buffers);
11078   }
11079   void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer)
11080   {
11081     fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
11082   }
11083   void add_metadata(
11084     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Metadata>>> metadata)
11085   {
11086     fbb_.AddOffset(Model::VT_METADATA, metadata);
11087   }
11088   void add_signature_defs(
11089     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SignatureDef>>>
11090       signature_defs)
11091   {
11092     fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
11093   }
11094   explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11095   {
11096     start_ = fbb_.StartTable();
11097   }
11098   flatbuffers::Offset<Model> Finish()
11099   {
11100     const auto end = fbb_.EndTable(start_);
11101     auto o = flatbuffers::Offset<Model>(end);
11102     return o;
11103   }
11104 };
11105
11106 inline flatbuffers::Offset<Model> CreateModel(
11107   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
11108   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::OperatorCode>>>
11109     operator_codes = 0,
11110   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SubGraph>>> subgraphs =
11111     0,
11112   flatbuffers::Offset<flatbuffers::String> description = 0,
11113   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Buffer>>> buffers = 0,
11114   flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
11115   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::Metadata>>> metadata =
11116     0,
11117   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<onert_tflite::SignatureDef>>>
11118     signature_defs = 0)
11119 {
11120   ModelBuilder builder_(_fbb);
11121   builder_.add_signature_defs(signature_defs);
11122   builder_.add_metadata(metadata);
11123   builder_.add_metadata_buffer(metadata_buffer);
11124   builder_.add_buffers(buffers);
11125   builder_.add_description(description);
11126   builder_.add_subgraphs(subgraphs);
11127   builder_.add_operator_codes(operator_codes);
11128   builder_.add_version(version);
11129   return builder_.Finish();
11130 }
11131
11132 inline flatbuffers::Offset<Model> CreateModelDirect(
11133   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
11134   const std::vector<flatbuffers::Offset<onert_tflite::OperatorCode>> *operator_codes = nullptr,
11135   const std::vector<flatbuffers::Offset<onert_tflite::SubGraph>> *subgraphs = nullptr,
11136   const char *description = nullptr,
11137   const std::vector<flatbuffers::Offset<onert_tflite::Buffer>> *buffers = nullptr,
11138   const std::vector<int32_t> *metadata_buffer = nullptr,
11139   const std::vector<flatbuffers::Offset<onert_tflite::Metadata>> *metadata = nullptr,
11140   const std::vector<flatbuffers::Offset<onert_tflite::SignatureDef>> *signature_defs = nullptr)
11141 {
11142   auto operator_codes__ =
11143     operator_codes
11144       ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::OperatorCode>>(*operator_codes)
11145       : 0;
11146   auto subgraphs__ =
11147     subgraphs ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::SubGraph>>(*subgraphs) : 0;
11148   auto description__ = description ? _fbb.CreateString(description) : 0;
11149   auto buffers__ =
11150     buffers ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::Buffer>>(*buffers) : 0;
11151   auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
11152   auto metadata__ =
11153     metadata ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::Metadata>>(*metadata) : 0;
11154   auto signature_defs__ =
11155     signature_defs
11156       ? _fbb.CreateVector<flatbuffers::Offset<onert_tflite::SignatureDef>>(*signature_defs)
11157       : 0;
11158   return onert_tflite::CreateModel(_fbb, version, operator_codes__, subgraphs__, description__,
11159                                    buffers__, metadata_buffer__, metadata__, signature_defs__);
11160 }
11161
11162 inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
11163                                       QuantizationDetails type)
11164 {
11165   switch (type)
11166   {
11167     case QuantizationDetails_NONE:
11168     {
11169       return true;
11170     }
11171     case QuantizationDetails_CustomQuantization:
11172     {
11173       auto ptr = reinterpret_cast<const onert_tflite::CustomQuantization *>(obj);
11174       return verifier.VerifyTable(ptr);
11175     }
11176     default:
11177       return true;
11178   }
11179 }
11180
11181 inline bool
11182 VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
11183                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
11184                                 const flatbuffers::Vector<uint8_t> *types)
11185 {
11186   if (!values || !types)
11187     return !values && !types;
11188   if (values->size() != types->size())
11189     return false;
11190   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
11191   {
11192     if (!VerifyQuantizationDetails(verifier, values->Get(i),
11193                                    types->GetEnum<QuantizationDetails>(i)))
11194     {
11195       return false;
11196     }
11197   }
11198   return true;
11199 }
11200
11201 inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
11202                                     SparseIndexVector type)
11203 {
11204   switch (type)
11205   {
11206     case SparseIndexVector_NONE:
11207     {
11208       return true;
11209     }
11210     case SparseIndexVector_Int32Vector:
11211     {
11212       auto ptr = reinterpret_cast<const onert_tflite::Int32Vector *>(obj);
11213       return verifier.VerifyTable(ptr);
11214     }
11215     case SparseIndexVector_Uint16Vector:
11216     {
11217       auto ptr = reinterpret_cast<const onert_tflite::Uint16Vector *>(obj);
11218       return verifier.VerifyTable(ptr);
11219     }
11220     case SparseIndexVector_Uint8Vector:
11221     {
11222       auto ptr = reinterpret_cast<const onert_tflite::Uint8Vector *>(obj);
11223       return verifier.VerifyTable(ptr);
11224     }
11225     default:
11226       return true;
11227   }
11228 }
11229
11230 inline bool
11231 VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
11232                               const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
11233                               const flatbuffers::Vector<uint8_t> *types)
11234 {
11235   if (!values || !types)
11236     return !values && !types;
11237   if (values->size() != types->size())
11238     return false;
11239   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
11240   {
11241     if (!VerifySparseIndexVector(verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i)))
11242     {
11243       return false;
11244     }
11245   }
11246   return true;
11247 }
11248
11249 inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj,
11250                                  BuiltinOptions type)
11251 {
11252   switch (type)
11253   {
11254     case BuiltinOptions_NONE:
11255     {
11256       return true;
11257     }
11258     case BuiltinOptions_Conv2DOptions:
11259     {
11260       auto ptr = reinterpret_cast<const onert_tflite::Conv2DOptions *>(obj);
11261       return verifier.VerifyTable(ptr);
11262     }
11263     case BuiltinOptions_DepthwiseConv2DOptions:
11264     {
11265       auto ptr = reinterpret_cast<const onert_tflite::DepthwiseConv2DOptions *>(obj);
11266       return verifier.VerifyTable(ptr);
11267     }
11268     case BuiltinOptions_ConcatEmbeddingsOptions:
11269     {
11270       auto ptr = reinterpret_cast<const onert_tflite::ConcatEmbeddingsOptions *>(obj);
11271       return verifier.VerifyTable(ptr);
11272     }
11273     case BuiltinOptions_LSHProjectionOptions:
11274     {
11275       auto ptr = reinterpret_cast<const onert_tflite::LSHProjectionOptions *>(obj);
11276       return verifier.VerifyTable(ptr);
11277     }
11278     case BuiltinOptions_Pool2DOptions:
11279     {
11280       auto ptr = reinterpret_cast<const onert_tflite::Pool2DOptions *>(obj);
11281       return verifier.VerifyTable(ptr);
11282     }
11283     case BuiltinOptions_SVDFOptions:
11284     {
11285       auto ptr = reinterpret_cast<const onert_tflite::SVDFOptions *>(obj);
11286       return verifier.VerifyTable(ptr);
11287     }
11288     case BuiltinOptions_RNNOptions:
11289     {
11290       auto ptr = reinterpret_cast<const onert_tflite::RNNOptions *>(obj);
11291       return verifier.VerifyTable(ptr);
11292     }
11293     case BuiltinOptions_FullyConnectedOptions:
11294     {
11295       auto ptr = reinterpret_cast<const onert_tflite::FullyConnectedOptions *>(obj);
11296       return verifier.VerifyTable(ptr);
11297     }
11298     case BuiltinOptions_SoftmaxOptions:
11299     {
11300       auto ptr = reinterpret_cast<const onert_tflite::SoftmaxOptions *>(obj);
11301       return verifier.VerifyTable(ptr);
11302     }
11303     case BuiltinOptions_ConcatenationOptions:
11304     {
11305       auto ptr = reinterpret_cast<const onert_tflite::ConcatenationOptions *>(obj);
11306       return verifier.VerifyTable(ptr);
11307     }
11308     case BuiltinOptions_AddOptions:
11309     {
11310       auto ptr = reinterpret_cast<const onert_tflite::AddOptions *>(obj);
11311       return verifier.VerifyTable(ptr);
11312     }
11313     case BuiltinOptions_L2NormOptions:
11314     {
11315       auto ptr = reinterpret_cast<const onert_tflite::L2NormOptions *>(obj);
11316       return verifier.VerifyTable(ptr);
11317     }
11318     case BuiltinOptions_LocalResponseNormalizationOptions:
11319     {
11320       auto ptr = reinterpret_cast<const onert_tflite::LocalResponseNormalizationOptions *>(obj);
11321       return verifier.VerifyTable(ptr);
11322     }
11323     case BuiltinOptions_LSTMOptions:
11324     {
11325       auto ptr = reinterpret_cast<const onert_tflite::LSTMOptions *>(obj);
11326       return verifier.VerifyTable(ptr);
11327     }
11328     case BuiltinOptions_ResizeBilinearOptions:
11329     {
11330       auto ptr = reinterpret_cast<const onert_tflite::ResizeBilinearOptions *>(obj);
11331       return verifier.VerifyTable(ptr);
11332     }
11333     case BuiltinOptions_CallOptions:
11334     {
11335       auto ptr = reinterpret_cast<const onert_tflite::CallOptions *>(obj);
11336       return verifier.VerifyTable(ptr);
11337     }
11338     case BuiltinOptions_ReshapeOptions:
11339     {
11340       auto ptr = reinterpret_cast<const onert_tflite::ReshapeOptions *>(obj);
11341       return verifier.VerifyTable(ptr);
11342     }
11343     case BuiltinOptions_SkipGramOptions:
11344     {
11345       auto ptr = reinterpret_cast<const onert_tflite::SkipGramOptions *>(obj);
11346       return verifier.VerifyTable(ptr);
11347     }
11348     case BuiltinOptions_SpaceToDepthOptions:
11349     {
11350       auto ptr = reinterpret_cast<const onert_tflite::SpaceToDepthOptions *>(obj);
11351       return verifier.VerifyTable(ptr);
11352     }
11353     case BuiltinOptions_EmbeddingLookupSparseOptions:
11354     {
11355       auto ptr = reinterpret_cast<const onert_tflite::EmbeddingLookupSparseOptions *>(obj);
11356       return verifier.VerifyTable(ptr);
11357     }
11358     case BuiltinOptions_MulOptions:
11359     {
11360       auto ptr = reinterpret_cast<const onert_tflite::MulOptions *>(obj);
11361       return verifier.VerifyTable(ptr);
11362     }
11363     case BuiltinOptions_PadOptions:
11364     {
11365       auto ptr = reinterpret_cast<const onert_tflite::PadOptions *>(obj);
11366       return verifier.VerifyTable(ptr);
11367     }
11368     case BuiltinOptions_GatherOptions:
11369     {
11370       auto ptr = reinterpret_cast<const onert_tflite::GatherOptions *>(obj);
11371       return verifier.VerifyTable(ptr);
11372     }
11373     case BuiltinOptions_BatchToSpaceNDOptions:
11374     {
11375       auto ptr = reinterpret_cast<const onert_tflite::BatchToSpaceNDOptions *>(obj);
11376       return verifier.VerifyTable(ptr);
11377     }
11378     case BuiltinOptions_SpaceToBatchNDOptions:
11379     {
11380       auto ptr = reinterpret_cast<const onert_tflite::SpaceToBatchNDOptions *>(obj);
11381       return verifier.VerifyTable(ptr);
11382     }
11383     case BuiltinOptions_TransposeOptions:
11384     {
11385       auto ptr = reinterpret_cast<const onert_tflite::TransposeOptions *>(obj);
11386       return verifier.VerifyTable(ptr);
11387     }
11388     case BuiltinOptions_ReducerOptions:
11389     {
11390       auto ptr = reinterpret_cast<const onert_tflite::ReducerOptions *>(obj);
11391       return verifier.VerifyTable(ptr);
11392     }
11393     case BuiltinOptions_SubOptions:
11394     {
11395       auto ptr = reinterpret_cast<const onert_tflite::SubOptions *>(obj);
11396       return verifier.VerifyTable(ptr);
11397     }
11398     case BuiltinOptions_DivOptions:
11399     {
11400       auto ptr = reinterpret_cast<const onert_tflite::DivOptions *>(obj);
11401       return verifier.VerifyTable(ptr);
11402     }
11403     case BuiltinOptions_SqueezeOptions:
11404     {
11405       auto ptr = reinterpret_cast<const onert_tflite::SqueezeOptions *>(obj);
11406       return verifier.VerifyTable(ptr);
11407     }
11408     case BuiltinOptions_SequenceRNNOptions:
11409     {
11410       auto ptr = reinterpret_cast<const onert_tflite::SequenceRNNOptions *>(obj);
11411       return verifier.VerifyTable(ptr);
11412     }
11413     case BuiltinOptions_StridedSliceOptions:
11414     {
11415       auto ptr = reinterpret_cast<const onert_tflite::StridedSliceOptions *>(obj);
11416       return verifier.VerifyTable(ptr);
11417     }
11418     case BuiltinOptions_ExpOptions:
11419     {
11420       auto ptr = reinterpret_cast<const onert_tflite::ExpOptions *>(obj);
11421       return verifier.VerifyTable(ptr);
11422     }
11423     case BuiltinOptions_TopKV2Options:
11424     {
11425       auto ptr = reinterpret_cast<const onert_tflite::TopKV2Options *>(obj);
11426       return verifier.VerifyTable(ptr);
11427     }
11428     case BuiltinOptions_SplitOptions:
11429     {
11430       auto ptr = reinterpret_cast<const onert_tflite::SplitOptions *>(obj);
11431       return verifier.VerifyTable(ptr);
11432     }
11433     case BuiltinOptions_LogSoftmaxOptions:
11434     {
11435       auto ptr = reinterpret_cast<const onert_tflite::LogSoftmaxOptions *>(obj);
11436       return verifier.VerifyTable(ptr);
11437     }
11438     case BuiltinOptions_CastOptions:
11439     {
11440       auto ptr = reinterpret_cast<const onert_tflite::CastOptions *>(obj);
11441       return verifier.VerifyTable(ptr);
11442     }
11443     case BuiltinOptions_DequantizeOptions:
11444     {
11445       auto ptr = reinterpret_cast<const onert_tflite::DequantizeOptions *>(obj);
11446       return verifier.VerifyTable(ptr);
11447     }
11448     case BuiltinOptions_MaximumMinimumOptions:
11449     {
11450       auto ptr = reinterpret_cast<const onert_tflite::MaximumMinimumOptions *>(obj);
11451       return verifier.VerifyTable(ptr);
11452     }
11453     case BuiltinOptions_ArgMaxOptions:
11454     {
11455       auto ptr = reinterpret_cast<const onert_tflite::ArgMaxOptions *>(obj);
11456       return verifier.VerifyTable(ptr);
11457     }
11458     case BuiltinOptions_LessOptions:
11459     {
11460       auto ptr = reinterpret_cast<const onert_tflite::LessOptions *>(obj);
11461       return verifier.VerifyTable(ptr);
11462     }
11463     case BuiltinOptions_NegOptions:
11464     {
11465       auto ptr = reinterpret_cast<const onert_tflite::NegOptions *>(obj);
11466       return verifier.VerifyTable(ptr);
11467     }
11468     case BuiltinOptions_PadV2Options:
11469     {
11470       auto ptr = reinterpret_cast<const onert_tflite::PadV2Options *>(obj);
11471       return verifier.VerifyTable(ptr);
11472     }
11473     case BuiltinOptions_GreaterOptions:
11474     {
11475       auto ptr = reinterpret_cast<const onert_tflite::GreaterOptions *>(obj);
11476       return verifier.VerifyTable(ptr);
11477     }
11478     case BuiltinOptions_GreaterEqualOptions:
11479     {
11480       auto ptr = reinterpret_cast<const onert_tflite::GreaterEqualOptions *>(obj);
11481       return verifier.VerifyTable(ptr);
11482     }
11483     case BuiltinOptions_LessEqualOptions:
11484     {
11485       auto ptr = reinterpret_cast<const onert_tflite::LessEqualOptions *>(obj);
11486       return verifier.VerifyTable(ptr);
11487     }
11488     case BuiltinOptions_SelectOptions:
11489     {
11490       auto ptr = reinterpret_cast<const onert_tflite::SelectOptions *>(obj);
11491       return verifier.VerifyTable(ptr);
11492     }
11493     case BuiltinOptions_SliceOptions:
11494     {
11495       auto ptr = reinterpret_cast<const onert_tflite::SliceOptions *>(obj);
11496       return verifier.VerifyTable(ptr);
11497     }
11498     case BuiltinOptions_TransposeConvOptions:
11499     {
11500       auto ptr = reinterpret_cast<const onert_tflite::TransposeConvOptions *>(obj);
11501       return verifier.VerifyTable(ptr);
11502     }
11503     case BuiltinOptions_SparseToDenseOptions:
11504     {
11505       auto ptr = reinterpret_cast<const onert_tflite::SparseToDenseOptions *>(obj);
11506       return verifier.VerifyTable(ptr);
11507     }
11508     case BuiltinOptions_TileOptions:
11509     {
11510       auto ptr = reinterpret_cast<const onert_tflite::TileOptions *>(obj);
11511       return verifier.VerifyTable(ptr);
11512     }
11513     case BuiltinOptions_ExpandDimsOptions:
11514     {
11515       auto ptr = reinterpret_cast<const onert_tflite::ExpandDimsOptions *>(obj);
11516       return verifier.VerifyTable(ptr);
11517     }
11518     case BuiltinOptions_EqualOptions:
11519     {
11520       auto ptr = reinterpret_cast<const onert_tflite::EqualOptions *>(obj);
11521       return verifier.VerifyTable(ptr);
11522     }
11523     case BuiltinOptions_NotEqualOptions:
11524     {
11525       auto ptr = reinterpret_cast<const onert_tflite::NotEqualOptions *>(obj);
11526       return verifier.VerifyTable(ptr);
11527     }
11528     case BuiltinOptions_ShapeOptions:
11529     {
11530       auto ptr = reinterpret_cast<const onert_tflite::ShapeOptions *>(obj);
11531       return verifier.VerifyTable(ptr);
11532     }
11533     case BuiltinOptions_PowOptions:
11534     {
11535       auto ptr = reinterpret_cast<const onert_tflite::PowOptions *>(obj);
11536       return verifier.VerifyTable(ptr);
11537     }
11538     case BuiltinOptions_ArgMinOptions:
11539     {
11540       auto ptr = reinterpret_cast<const onert_tflite::ArgMinOptions *>(obj);
11541       return verifier.VerifyTable(ptr);
11542     }
11543     case BuiltinOptions_FakeQuantOptions:
11544     {
11545       auto ptr = reinterpret_cast<const onert_tflite::FakeQuantOptions *>(obj);
11546       return verifier.VerifyTable(ptr);
11547     }
11548     case BuiltinOptions_PackOptions:
11549     {
11550       auto ptr = reinterpret_cast<const onert_tflite::PackOptions *>(obj);
11551       return verifier.VerifyTable(ptr);
11552     }
11553     case BuiltinOptions_LogicalOrOptions:
11554     {
11555       auto ptr = reinterpret_cast<const onert_tflite::LogicalOrOptions *>(obj);
11556       return verifier.VerifyTable(ptr);
11557     }
11558     case BuiltinOptions_OneHotOptions:
11559     {
11560       auto ptr = reinterpret_cast<const onert_tflite::OneHotOptions *>(obj);
11561       return verifier.VerifyTable(ptr);
11562     }
11563     case BuiltinOptions_LogicalAndOptions:
11564     {
11565       auto ptr = reinterpret_cast<const onert_tflite::LogicalAndOptions *>(obj);
11566       return verifier.VerifyTable(ptr);
11567     }
11568     case BuiltinOptions_LogicalNotOptions:
11569     {
11570       auto ptr = reinterpret_cast<const onert_tflite::LogicalNotOptions *>(obj);
11571       return verifier.VerifyTable(ptr);
11572     }
11573     case BuiltinOptions_UnpackOptions:
11574     {
11575       auto ptr = reinterpret_cast<const onert_tflite::UnpackOptions *>(obj);
11576       return verifier.VerifyTable(ptr);
11577     }
11578     case BuiltinOptions_FloorDivOptions:
11579     {
11580       auto ptr = reinterpret_cast<const onert_tflite::FloorDivOptions *>(obj);
11581       return verifier.VerifyTable(ptr);
11582     }
11583     case BuiltinOptions_SquareOptions:
11584     {
11585       auto ptr = reinterpret_cast<const onert_tflite::SquareOptions *>(obj);
11586       return verifier.VerifyTable(ptr);
11587     }
11588     case BuiltinOptions_ZerosLikeOptions:
11589     {
11590       auto ptr = reinterpret_cast<const onert_tflite::ZerosLikeOptions *>(obj);
11591       return verifier.VerifyTable(ptr);
11592     }
11593     case BuiltinOptions_FillOptions:
11594     {
11595       auto ptr = reinterpret_cast<const onert_tflite::FillOptions *>(obj);
11596       return verifier.VerifyTable(ptr);
11597     }
11598     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
11599     {
11600       auto ptr = reinterpret_cast<const onert_tflite::BidirectionalSequenceLSTMOptions *>(obj);
11601       return verifier.VerifyTable(ptr);
11602     }
11603     case BuiltinOptions_BidirectionalSequenceRNNOptions:
11604     {
11605       auto ptr = reinterpret_cast<const onert_tflite::BidirectionalSequenceRNNOptions *>(obj);
11606       return verifier.VerifyTable(ptr);
11607     }
11608     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
11609     {
11610       auto ptr = reinterpret_cast<const onert_tflite::UnidirectionalSequenceLSTMOptions *>(obj);
11611       return verifier.VerifyTable(ptr);
11612     }
11613     case BuiltinOptions_FloorModOptions:
11614     {
11615       auto ptr = reinterpret_cast<const onert_tflite::FloorModOptions *>(obj);
11616       return verifier.VerifyTable(ptr);
11617     }
11618     case BuiltinOptions_RangeOptions:
11619     {
11620       auto ptr = reinterpret_cast<const onert_tflite::RangeOptions *>(obj);
11621       return verifier.VerifyTable(ptr);
11622     }
11623     case BuiltinOptions_ResizeNearestNeighborOptions:
11624     {
11625       auto ptr = reinterpret_cast<const onert_tflite::ResizeNearestNeighborOptions *>(obj);
11626       return verifier.VerifyTable(ptr);
11627     }
11628     case BuiltinOptions_LeakyReluOptions:
11629     {
11630       auto ptr = reinterpret_cast<const onert_tflite::LeakyReluOptions *>(obj);
11631       return verifier.VerifyTable(ptr);
11632     }
11633     case BuiltinOptions_SquaredDifferenceOptions:
11634     {
11635       auto ptr = reinterpret_cast<const onert_tflite::SquaredDifferenceOptions *>(obj);
11636       return verifier.VerifyTable(ptr);
11637     }
11638     case BuiltinOptions_MirrorPadOptions:
11639     {
11640       auto ptr = reinterpret_cast<const onert_tflite::MirrorPadOptions *>(obj);
11641       return verifier.VerifyTable(ptr);
11642     }
11643     case BuiltinOptions_AbsOptions:
11644     {
11645       auto ptr = reinterpret_cast<const onert_tflite::AbsOptions *>(obj);
11646       return verifier.VerifyTable(ptr);
11647     }
11648     case BuiltinOptions_SplitVOptions:
11649     {
11650       auto ptr = reinterpret_cast<const onert_tflite::SplitVOptions *>(obj);
11651       return verifier.VerifyTable(ptr);
11652     }
11653     case BuiltinOptions_UniqueOptions:
11654     {
11655       auto ptr = reinterpret_cast<const onert_tflite::UniqueOptions *>(obj);
11656       return verifier.VerifyTable(ptr);
11657     }
11658     case BuiltinOptions_ReverseV2Options:
11659     {
11660       auto ptr = reinterpret_cast<const onert_tflite::ReverseV2Options *>(obj);
11661       return verifier.VerifyTable(ptr);
11662     }
11663     case BuiltinOptions_AddNOptions:
11664     {
11665       auto ptr = reinterpret_cast<const onert_tflite::AddNOptions *>(obj);
11666       return verifier.VerifyTable(ptr);
11667     }
11668     case BuiltinOptions_GatherNdOptions:
11669     {
11670       auto ptr = reinterpret_cast<const onert_tflite::GatherNdOptions *>(obj);
11671       return verifier.VerifyTable(ptr);
11672     }
11673     case BuiltinOptions_CosOptions:
11674     {
11675       auto ptr = reinterpret_cast<const onert_tflite::CosOptions *>(obj);
11676       return verifier.VerifyTable(ptr);
11677     }
11678     case BuiltinOptions_WhereOptions:
11679     {
11680       auto ptr = reinterpret_cast<const onert_tflite::WhereOptions *>(obj);
11681       return verifier.VerifyTable(ptr);
11682     }
11683     case BuiltinOptions_RankOptions:
11684     {
11685       auto ptr = reinterpret_cast<const onert_tflite::RankOptions *>(obj);
11686       return verifier.VerifyTable(ptr);
11687     }
11688     case BuiltinOptions_ReverseSequenceOptions:
11689     {
11690       auto ptr = reinterpret_cast<const onert_tflite::ReverseSequenceOptions *>(obj);
11691       return verifier.VerifyTable(ptr);
11692     }
11693     case BuiltinOptions_MatrixDiagOptions:
11694     {
11695       auto ptr = reinterpret_cast<const onert_tflite::MatrixDiagOptions *>(obj);
11696       return verifier.VerifyTable(ptr);
11697     }
11698     case BuiltinOptions_QuantizeOptions:
11699     {
11700       auto ptr = reinterpret_cast<const onert_tflite::QuantizeOptions *>(obj);
11701       return verifier.VerifyTable(ptr);
11702     }
11703     case BuiltinOptions_MatrixSetDiagOptions:
11704     {
11705       auto ptr = reinterpret_cast<const onert_tflite::MatrixSetDiagOptions *>(obj);
11706       return verifier.VerifyTable(ptr);
11707     }
11708     case BuiltinOptions_HardSwishOptions:
11709     {
11710       auto ptr = reinterpret_cast<const onert_tflite::HardSwishOptions *>(obj);
11711       return verifier.VerifyTable(ptr);
11712     }
11713     case BuiltinOptions_IfOptions:
11714     {
11715       auto ptr = reinterpret_cast<const onert_tflite::IfOptions *>(obj);
11716       return verifier.VerifyTable(ptr);
11717     }
11718     case BuiltinOptions_WhileOptions:
11719     {
11720       auto ptr = reinterpret_cast<const onert_tflite::WhileOptions *>(obj);
11721       return verifier.VerifyTable(ptr);
11722     }
11723     case BuiltinOptions_DepthToSpaceOptions:
11724     {
11725       auto ptr = reinterpret_cast<const onert_tflite::DepthToSpaceOptions *>(obj);
11726       return verifier.VerifyTable(ptr);
11727     }
11728     case BuiltinOptions_NonMaxSuppressionV4Options:
11729     {
11730       auto ptr = reinterpret_cast<const onert_tflite::NonMaxSuppressionV4Options *>(obj);
11731       return verifier.VerifyTable(ptr);
11732     }
11733     case BuiltinOptions_NonMaxSuppressionV5Options:
11734     {
11735       auto ptr = reinterpret_cast<const onert_tflite::NonMaxSuppressionV5Options *>(obj);
11736       return verifier.VerifyTable(ptr);
11737     }
11738     case BuiltinOptions_ScatterNdOptions:
11739     {
11740       auto ptr = reinterpret_cast<const onert_tflite::ScatterNdOptions *>(obj);
11741       return verifier.VerifyTable(ptr);
11742     }
11743     case BuiltinOptions_SelectV2Options:
11744     {
11745       auto ptr = reinterpret_cast<const onert_tflite::SelectV2Options *>(obj);
11746       return verifier.VerifyTable(ptr);
11747     }
11748     case BuiltinOptions_DensifyOptions:
11749     {
11750       auto ptr = reinterpret_cast<const onert_tflite::DensifyOptions *>(obj);
11751       return verifier.VerifyTable(ptr);
11752     }
11753     case BuiltinOptions_SegmentSumOptions:
11754     {
11755       auto ptr = reinterpret_cast<const onert_tflite::SegmentSumOptions *>(obj);
11756       return verifier.VerifyTable(ptr);
11757     }
11758     case BuiltinOptions_BatchMatMulOptions:
11759     {
11760       auto ptr = reinterpret_cast<const onert_tflite::BatchMatMulOptions *>(obj);
11761       return verifier.VerifyTable(ptr);
11762     }
11763     case BuiltinOptions_CumsumOptions:
11764     {
11765       auto ptr = reinterpret_cast<const onert_tflite::CumsumOptions *>(obj);
11766       return verifier.VerifyTable(ptr);
11767     }
11768     case BuiltinOptions_CallOnceOptions:
11769     {
11770       auto ptr = reinterpret_cast<const onert_tflite::CallOnceOptions *>(obj);
11771       return verifier.VerifyTable(ptr);
11772     }
11773     case BuiltinOptions_BroadcastToOptions:
11774     {
11775       auto ptr = reinterpret_cast<const onert_tflite::BroadcastToOptions *>(obj);
11776       return verifier.VerifyTable(ptr);
11777     }
11778     case BuiltinOptions_Rfft2dOptions:
11779     {
11780       auto ptr = reinterpret_cast<const onert_tflite::Rfft2dOptions *>(obj);
11781       return verifier.VerifyTable(ptr);
11782     }
11783     case BuiltinOptions_Conv3DOptions:
11784     {
11785       auto ptr = reinterpret_cast<const onert_tflite::Conv3DOptions *>(obj);
11786       return verifier.VerifyTable(ptr);
11787     }
11788     case BuiltinOptions_HashtableOptions:
11789     {
11790       auto ptr = reinterpret_cast<const onert_tflite::HashtableOptions *>(obj);
11791       return verifier.VerifyTable(ptr);
11792     }
11793     case BuiltinOptions_HashtableFindOptions:
11794     {
11795       auto ptr = reinterpret_cast<const onert_tflite::HashtableFindOptions *>(obj);
11796       return verifier.VerifyTable(ptr);
11797     }
11798     case BuiltinOptions_HashtableImportOptions:
11799     {
11800       auto ptr = reinterpret_cast<const onert_tflite::HashtableImportOptions *>(obj);
11801       return verifier.VerifyTable(ptr);
11802     }
11803     case BuiltinOptions_HashtableSizeOptions:
11804     {
11805       auto ptr = reinterpret_cast<const onert_tflite::HashtableSizeOptions *>(obj);
11806       return verifier.VerifyTable(ptr);
11807     }
11808     case BuiltinOptions_VarHandleOptions:
11809     {
11810       auto ptr = reinterpret_cast<const onert_tflite::VarHandleOptions *>(obj);
11811       return verifier.VerifyTable(ptr);
11812     }
11813     case BuiltinOptions_ReadVariableOptions:
11814     {
11815       auto ptr = reinterpret_cast<const onert_tflite::ReadVariableOptions *>(obj);
11816       return verifier.VerifyTable(ptr);
11817     }
11818     case BuiltinOptions_AssignVariableOptions:
11819     {
11820       auto ptr = reinterpret_cast<const onert_tflite::AssignVariableOptions *>(obj);
11821       return verifier.VerifyTable(ptr);
11822     }
11823     case BuiltinOptions_RandomOptions:
11824     {
11825       auto ptr = reinterpret_cast<const onert_tflite::RandomOptions *>(obj);
11826       return verifier.VerifyTable(ptr);
11827     }
11828     case BuiltinOptions_BucketizeOptions:
11829     {
11830       auto ptr = reinterpret_cast<const onert_tflite::BucketizeOptions *>(obj);
11831       return verifier.VerifyTable(ptr);
11832     }
11833     case BuiltinOptions_GeluOptions:
11834     {
11835       auto ptr = reinterpret_cast<const onert_tflite::GeluOptions *>(obj);
11836       return verifier.VerifyTable(ptr);
11837     }
11838     case BuiltinOptions_DynamicUpdateSliceOptions:
11839     {
11840       auto ptr = reinterpret_cast<const onert_tflite::DynamicUpdateSliceOptions *>(obj);
11841       return verifier.VerifyTable(ptr);
11842     }
11843     case BuiltinOptions_UnsortedSegmentProdOptions:
11844     {
11845       auto ptr = reinterpret_cast<const onert_tflite::UnsortedSegmentProdOptions *>(obj);
11846       return verifier.VerifyTable(ptr);
11847     }
11848     case BuiltinOptions_UnsortedSegmentMaxOptions:
11849     {
11850       auto ptr = reinterpret_cast<const onert_tflite::UnsortedSegmentMaxOptions *>(obj);
11851       return verifier.VerifyTable(ptr);
11852     }
11853     case BuiltinOptions_UnsortedSegmentSumOptions:
11854     {
11855       auto ptr = reinterpret_cast<const onert_tflite::UnsortedSegmentSumOptions *>(obj);
11856       return verifier.VerifyTable(ptr);
11857     }
11858     case BuiltinOptions_ATan2Options:
11859     {
11860       auto ptr = reinterpret_cast<const onert_tflite::ATan2Options *>(obj);
11861       return verifier.VerifyTable(ptr);
11862     }
11863     default:
11864       return true;
11865   }
11866 }
11867
11868 inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
11869                                        const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
11870                                        const flatbuffers::Vector<uint8_t> *types)
11871 {
11872   if (!values || !types)
11873     return !values && !types;
11874   if (values->size() != types->size())
11875     return false;
11876   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
11877   {
11878     if (!VerifyBuiltinOptions(verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i)))
11879     {
11880       return false;
11881     }
11882   }
11883   return true;
11884 }
11885
11886 inline const onert_tflite::Model *GetModel(const void *buf)
11887 {
11888   return flatbuffers::GetRoot<onert_tflite::Model>(buf);
11889 }
11890
11891 inline const onert_tflite::Model *GetSizePrefixedModel(const void *buf)
11892 {
11893   return flatbuffers::GetSizePrefixedRoot<onert_tflite::Model>(buf);
11894 }
11895
11896 inline const char *ModelIdentifier() { return "TFL3"; }
11897
11898 inline bool ModelBufferHasIdentifier(const void *buf)
11899 {
11900   return flatbuffers::BufferHasIdentifier(buf, ModelIdentifier());
11901 }
11902
11903 inline bool VerifyModelBuffer(flatbuffers::Verifier &verifier)
11904 {
11905   return verifier.VerifyBuffer<onert_tflite::Model>(ModelIdentifier());
11906 }
11907
11908 inline bool VerifySizePrefixedModelBuffer(flatbuffers::Verifier &verifier)
11909 {
11910   return verifier.VerifySizePrefixedBuffer<onert_tflite::Model>(ModelIdentifier());
11911 }
11912
11913 inline const char *ModelExtension() { return "tflite"; }
11914
11915 inline void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
11916                               flatbuffers::Offset<onert_tflite::Model> root)
11917 {
11918   fbb.Finish(root, ModelIdentifier());
11919 }
11920
11921 inline void FinishSizePrefixedModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
11922                                           flatbuffers::Offset<onert_tflite::Model> root)
11923 {
11924   fbb.FinishSizePrefixed(root, ModelIdentifier());
11925 }
11926
11927 } // namespace onert_tflite
11928
11929 #endif // FLATBUFFERS_GENERATED_TFLITESCHEMA_ONERT_TFLITE_H_