runtime/onert/frontend/circle_schema/include/circle_schema_generated.h

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