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, ActivationFunctionType_RELU_N1_TO_1,
2159     ActivationFunctionType_RELU6, ActivationFunctionType_TANH, ActivationFunctionType_SIGN_BIT};
2160   return values;
2161 }
2162
2163 inline const char *const *EnumNamesActivationFunctionType()
2164 {
2165   static const char *const names[7] = {"NONE", "RELU",     "RELU_N1_TO_1", "RELU6",
2166                                        "TANH", "SIGN_BIT", nullptr};
2167   return names;
2168 }
2169
2170 inline const char *EnumNameActivationFunctionType(ActivationFunctionType e)
2171 {
2172   if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT))
2173     return "";
2174   const size_t index = static_cast<size_t>(e);
2175   return EnumNamesActivationFunctionType()[index];
2176 }
2177
2178 enum LSHProjectionType
2179 {
2180   LSHProjectionType_UNKNOWN = 0,
2181   LSHProjectionType_SPARSE = 1,
2182   LSHProjectionType_DENSE = 2,
2183   LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
2184   LSHProjectionType_MAX = LSHProjectionType_DENSE
2185 };
2186
2187 inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3]
2188 {
2189   static const LSHProjectionType values[] = {LSHProjectionType_UNKNOWN, LSHProjectionType_SPARSE,
2190                                              LSHProjectionType_DENSE};
2191   return values;
2192 }
2193
2194 inline const char *const *EnumNamesLSHProjectionType()
2195 {
2196   static const char *const names[4] = {"UNKNOWN", "SPARSE", "DENSE", nullptr};
2197   return names;
2198 }
2199
2200 inline const char *EnumNameLSHProjectionType(LSHProjectionType e)
2201 {
2202   if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE))
2203     return "";
2204   const size_t index = static_cast<size_t>(e);
2205   return EnumNamesLSHProjectionType()[index];
2206 }
2207
2208 enum FullyConnectedOptionsWeightsFormat
2209 {
2210   FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
2211   FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
2212   FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32 = 127,
2213   FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
2214   FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32
2215 };
2216
2217 inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[3]
2218 {
2219   static const FullyConnectedOptionsWeightsFormat values[] = {
2220     FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8,
2221     FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32};
2222   return values;
2223 }
2224
2225 inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e)
2226 {
2227   switch (e)
2228   {
2229     case FullyConnectedOptionsWeightsFormat_DEFAULT:
2230       return "DEFAULT";
2231     case FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8:
2232       return "SHUFFLED4x16INT8";
2233     case FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32:
2234       return "SHUFFLED16x1FLOAT32";
2235     default:
2236       return "";
2237   }
2238 }
2239
2240 enum LSTMKernelType
2241 {
2242   LSTMKernelType_FULL = 0,
2243   LSTMKernelType_BASIC = 1,
2244   LSTMKernelType_MIN = LSTMKernelType_FULL,
2245   LSTMKernelType_MAX = LSTMKernelType_BASIC
2246 };
2247
2248 inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2]
2249 {
2250   static const LSTMKernelType values[] = {LSTMKernelType_FULL, LSTMKernelType_BASIC};
2251   return values;
2252 }
2253
2254 inline const char *const *EnumNamesLSTMKernelType()
2255 {
2256   static const char *const names[3] = {"FULL", "BASIC", nullptr};
2257   return names;
2258 }
2259
2260 inline const char *EnumNameLSTMKernelType(LSTMKernelType e)
2261 {
2262   if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC))
2263     return "";
2264   const size_t index = static_cast<size_t>(e);
2265   return EnumNamesLSTMKernelType()[index];
2266 }
2267
2268 enum CombinerType
2269 {
2270   CombinerType_SUM = 0,
2271   CombinerType_MEAN = 1,
2272   CombinerType_SQRTN = 2,
2273   CombinerType_MIN = CombinerType_SUM,
2274   CombinerType_MAX = CombinerType_SQRTN
2275 };
2276
2277 inline const CombinerType (&EnumValuesCombinerType())[3]
2278 {
2279   static const CombinerType values[] = {CombinerType_SUM, CombinerType_MEAN, CombinerType_SQRTN};
2280   return values;
2281 }
2282
2283 inline const char *const *EnumNamesCombinerType()
2284 {
2285   static const char *const names[4] = {"SUM", "MEAN", "SQRTN", nullptr};
2286   return names;
2287 }
2288
2289 inline const char *EnumNameCombinerType(CombinerType e)
2290 {
2291   if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN))
2292     return "";
2293   const size_t index = static_cast<size_t>(e);
2294   return EnumNamesCombinerType()[index];
2295 }
2296
2297 enum MirrorPadMode
2298 {
2299   MirrorPadMode_REFLECT = 0,
2300   MirrorPadMode_SYMMETRIC = 1,
2301   MirrorPadMode_MIN = MirrorPadMode_REFLECT,
2302   MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
2303 };
2304
2305 inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2]
2306 {
2307   static const MirrorPadMode values[] = {MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC};
2308   return values;
2309 }
2310
2311 inline const char *const *EnumNamesMirrorPadMode()
2312 {
2313   static const char *const names[3] = {"REFLECT", "SYMMETRIC", nullptr};
2314   return names;
2315 }
2316
2317 inline const char *EnumNameMirrorPadMode(MirrorPadMode e)
2318 {
2319   if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC))
2320     return "";
2321   const size_t index = static_cast<size_t>(e);
2322   return EnumNamesMirrorPadMode()[index];
2323 }
2324
2325 enum CustomOptionsFormat
2326 {
2327   CustomOptionsFormat_FLEXBUFFERS = 0,
2328   CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
2329   CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
2330 };
2331
2332 inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1]
2333 {
2334   static const CustomOptionsFormat values[] = {CustomOptionsFormat_FLEXBUFFERS};
2335   return values;
2336 }
2337
2338 inline const char *const *EnumNamesCustomOptionsFormat()
2339 {
2340   static const char *const names[2] = {"FLEXBUFFERS", nullptr};
2341   return names;
2342 }
2343
2344 inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e)
2345 {
2346   if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS))
2347     return "";
2348   const size_t index = static_cast<size_t>(e);
2349   return EnumNamesCustomOptionsFormat()[index];
2350 }
2351
2352 enum DataFormat
2353 {
2354   DataFormat_CHANNELS_LAST = 0,
2355   DataFormat_CHANNELS_FIRST = 1,
2356   DataFormat_MIN = DataFormat_CHANNELS_LAST,
2357   DataFormat_MAX = DataFormat_CHANNELS_FIRST
2358 };
2359
2360 inline const DataFormat (&EnumValuesDataFormat())[2]
2361 {
2362   static const DataFormat values[] = {DataFormat_CHANNELS_LAST, DataFormat_CHANNELS_FIRST};
2363   return values;
2364 }
2365
2366 inline const char *const *EnumNamesDataFormat()
2367 {
2368   static const char *const names[3] = {"CHANNELS_LAST", "CHANNELS_FIRST", nullptr};
2369   return names;
2370 }
2371
2372 inline const char *EnumNameDataFormat(DataFormat e)
2373 {
2374   if (flatbuffers::IsOutRange(e, DataFormat_CHANNELS_LAST, DataFormat_CHANNELS_FIRST))
2375     return "";
2376   const size_t index = static_cast<size_t>(e);
2377   return EnumNamesDataFormat()[index];
2378 }
2379
2380 struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2381 {
2382   typedef CustomQuantizationBuilder Builder;
2383   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2384   {
2385     VT_CUSTOM = 4
2386   };
2387   const flatbuffers::Vector<uint8_t> *custom() const
2388   {
2389     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
2390   }
2391   bool Verify(flatbuffers::Verifier &verifier) const
2392   {
2393     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CUSTOM) &&
2394            verifier.VerifyVector(custom()) && verifier.EndTable();
2395   }
2396 };
2397
2398 struct CustomQuantizationBuilder
2399 {
2400   typedef CustomQuantization Table;
2401   flatbuffers::FlatBufferBuilder &fbb_;
2402   flatbuffers::uoffset_t start_;
2403   void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom)
2404   {
2405     fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
2406   }
2407   explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2408   {
2409     start_ = fbb_.StartTable();
2410   }
2411   CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &);
2412   flatbuffers::Offset<CustomQuantization> Finish()
2413   {
2414     const auto end = fbb_.EndTable(start_);
2415     auto o = flatbuffers::Offset<CustomQuantization>(end);
2416     return o;
2417   }
2418 };
2419
2420 inline flatbuffers::Offset<CustomQuantization>
2421 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb,
2422                          flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0)
2423 {
2424   CustomQuantizationBuilder builder_(_fbb);
2425   builder_.add_custom(custom);
2426   return builder_.Finish();
2427 }
2428
2429 inline flatbuffers::Offset<CustomQuantization>
2430 CreateCustomQuantizationDirect(flatbuffers::FlatBufferBuilder &_fbb,
2431                                const std::vector<uint8_t> *custom = nullptr)
2432 {
2433   if (custom)
2434   {
2435     _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16);
2436   }
2437   auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
2438   return circle::CreateCustomQuantization(_fbb, custom__);
2439 }
2440
2441 struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2442 {
2443   typedef QuantizationParametersBuilder Builder;
2444   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2445   {
2446     VT_MIN = 4,
2447     VT_MAX = 6,
2448     VT_SCALE = 8,
2449     VT_ZERO_POINT = 10,
2450     VT_DETAILS_TYPE = 12,
2451     VT_DETAILS = 14,
2452     VT_QUANTIZED_DIMENSION = 16
2453   };
2454   const flatbuffers::Vector<float> *min() const
2455   {
2456     return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
2457   }
2458   const flatbuffers::Vector<float> *max() const
2459   {
2460     return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
2461   }
2462   const flatbuffers::Vector<float> *scale() const
2463   {
2464     return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
2465   }
2466   const flatbuffers::Vector<int64_t> *zero_point() const
2467   {
2468     return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
2469   }
2470   circle::QuantizationDetails details_type() const
2471   {
2472     return static_cast<circle::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
2473   }
2474   const void *details() const { return GetPointer<const void *>(VT_DETAILS); }
2475   template <typename T> const T *details_as() const;
2476   const circle::CustomQuantization *details_as_CustomQuantization() const
2477   {
2478     return details_type() == circle::QuantizationDetails_CustomQuantization
2479              ? static_cast<const circle::CustomQuantization *>(details())
2480              : nullptr;
2481   }
2482   int32_t quantized_dimension() const { return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0); }
2483   bool Verify(flatbuffers::Verifier &verifier) const
2484   {
2485     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) &&
2486            verifier.VerifyVector(min()) && VerifyOffset(verifier, VT_MAX) &&
2487            verifier.VerifyVector(max()) && VerifyOffset(verifier, VT_SCALE) &&
2488            verifier.VerifyVector(scale()) && VerifyOffset(verifier, VT_ZERO_POINT) &&
2489            verifier.VerifyVector(zero_point()) && VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
2490            VerifyOffset(verifier, VT_DETAILS) &&
2491            VerifyQuantizationDetails(verifier, details(), details_type()) &&
2492            VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) && verifier.EndTable();
2493   }
2494 };
2495
2496 template <>
2497 inline const circle::CustomQuantization *
2498 QuantizationParameters::details_as<circle::CustomQuantization>() const
2499 {
2500   return details_as_CustomQuantization();
2501 }
2502
2503 struct QuantizationParametersBuilder
2504 {
2505   typedef QuantizationParameters Table;
2506   flatbuffers::FlatBufferBuilder &fbb_;
2507   flatbuffers::uoffset_t start_;
2508   void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min)
2509   {
2510     fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
2511   }
2512   void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max)
2513   {
2514     fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
2515   }
2516   void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale)
2517   {
2518     fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
2519   }
2520   void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point)
2521   {
2522     fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
2523   }
2524   void add_details_type(circle::QuantizationDetails details_type)
2525   {
2526     fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE,
2527                              static_cast<uint8_t>(details_type), 0);
2528   }
2529   void add_details(flatbuffers::Offset<void> details)
2530   {
2531     fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
2532   }
2533   void add_quantized_dimension(int32_t quantized_dimension)
2534   {
2535     fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension,
2536                              0);
2537   }
2538   explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2539   {
2540     start_ = fbb_.StartTable();
2541   }
2542   QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &);
2543   flatbuffers::Offset<QuantizationParameters> Finish()
2544   {
2545     const auto end = fbb_.EndTable(start_);
2546     auto o = flatbuffers::Offset<QuantizationParameters>(end);
2547     return o;
2548   }
2549 };
2550
2551 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
2552   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
2553   flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
2554   flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
2555   flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
2556   circle::QuantizationDetails details_type = circle::QuantizationDetails_NONE,
2557   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2558 {
2559   QuantizationParametersBuilder builder_(_fbb);
2560   builder_.add_quantized_dimension(quantized_dimension);
2561   builder_.add_details(details);
2562   builder_.add_zero_point(zero_point);
2563   builder_.add_scale(scale);
2564   builder_.add_max(max);
2565   builder_.add_min(min);
2566   builder_.add_details_type(details_type);
2567   return builder_.Finish();
2568 }
2569
2570 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
2571   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<float> *min = nullptr,
2572   const std::vector<float> *max = nullptr, const std::vector<float> *scale = nullptr,
2573   const std::vector<int64_t> *zero_point = nullptr,
2574   circle::QuantizationDetails details_type = circle::QuantizationDetails_NONE,
2575   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
2576 {
2577   auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
2578   auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
2579   auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
2580   auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
2581   return circle::CreateQuantizationParameters(_fbb, min__, max__, scale__, zero_point__,
2582                                               details_type, details, quantized_dimension);
2583 }
2584
2585 struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2586 {
2587   typedef Int32VectorBuilder Builder;
2588   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2589   {
2590     VT_VALUES = 4
2591   };
2592   const flatbuffers::Vector<int32_t> *values() const
2593   {
2594     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
2595   }
2596   bool Verify(flatbuffers::Verifier &verifier) const
2597   {
2598     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2599            verifier.VerifyVector(values()) && verifier.EndTable();
2600   }
2601 };
2602
2603 struct Int32VectorBuilder
2604 {
2605   typedef Int32Vector Table;
2606   flatbuffers::FlatBufferBuilder &fbb_;
2607   flatbuffers::uoffset_t start_;
2608   void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values)
2609   {
2610     fbb_.AddOffset(Int32Vector::VT_VALUES, values);
2611   }
2612   explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2613   {
2614     start_ = fbb_.StartTable();
2615   }
2616   Int32VectorBuilder &operator=(const Int32VectorBuilder &);
2617   flatbuffers::Offset<Int32Vector> Finish()
2618   {
2619     const auto end = fbb_.EndTable(start_);
2620     auto o = flatbuffers::Offset<Int32Vector>(end);
2621     return o;
2622   }
2623 };
2624
2625 inline flatbuffers::Offset<Int32Vector>
2626 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb,
2627                   flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0)
2628 {
2629   Int32VectorBuilder builder_(_fbb);
2630   builder_.add_values(values);
2631   return builder_.Finish();
2632 }
2633
2634 inline flatbuffers::Offset<Int32Vector>
2635 CreateInt32VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2636                         const std::vector<int32_t> *values = nullptr)
2637 {
2638   auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
2639   return circle::CreateInt32Vector(_fbb, values__);
2640 }
2641
2642 struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2643 {
2644   typedef Uint16VectorBuilder Builder;
2645   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2646   {
2647     VT_VALUES = 4
2648   };
2649   const flatbuffers::Vector<uint16_t> *values() const
2650   {
2651     return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
2652   }
2653   bool Verify(flatbuffers::Verifier &verifier) const
2654   {
2655     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2656            verifier.VerifyVector(values()) && verifier.EndTable();
2657   }
2658 };
2659
2660 struct Uint16VectorBuilder
2661 {
2662   typedef Uint16Vector Table;
2663   flatbuffers::FlatBufferBuilder &fbb_;
2664   flatbuffers::uoffset_t start_;
2665   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values)
2666   {
2667     fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
2668   }
2669   explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2670   {
2671     start_ = fbb_.StartTable();
2672   }
2673   Uint16VectorBuilder &operator=(const Uint16VectorBuilder &);
2674   flatbuffers::Offset<Uint16Vector> Finish()
2675   {
2676     const auto end = fbb_.EndTable(start_);
2677     auto o = flatbuffers::Offset<Uint16Vector>(end);
2678     return o;
2679   }
2680 };
2681
2682 inline flatbuffers::Offset<Uint16Vector>
2683 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb,
2684                    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0)
2685 {
2686   Uint16VectorBuilder builder_(_fbb);
2687   builder_.add_values(values);
2688   return builder_.Finish();
2689 }
2690
2691 inline flatbuffers::Offset<Uint16Vector>
2692 CreateUint16VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2693                          const std::vector<uint16_t> *values = nullptr)
2694 {
2695   if (values)
2696   {
2697     _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4);
2698   }
2699   auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
2700   return circle::CreateUint16Vector(_fbb, values__);
2701 }
2702
2703 struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2704 {
2705   typedef Uint8VectorBuilder Builder;
2706   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2707   {
2708     VT_VALUES = 4
2709   };
2710   const flatbuffers::Vector<uint8_t> *values() const
2711   {
2712     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
2713   }
2714   bool Verify(flatbuffers::Verifier &verifier) const
2715   {
2716     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
2717            verifier.VerifyVector(values()) && verifier.EndTable();
2718   }
2719 };
2720
2721 struct Uint8VectorBuilder
2722 {
2723   typedef Uint8Vector Table;
2724   flatbuffers::FlatBufferBuilder &fbb_;
2725   flatbuffers::uoffset_t start_;
2726   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values)
2727   {
2728     fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
2729   }
2730   explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2731   {
2732     start_ = fbb_.StartTable();
2733   }
2734   Uint8VectorBuilder &operator=(const Uint8VectorBuilder &);
2735   flatbuffers::Offset<Uint8Vector> Finish()
2736   {
2737     const auto end = fbb_.EndTable(start_);
2738     auto o = flatbuffers::Offset<Uint8Vector>(end);
2739     return o;
2740   }
2741 };
2742
2743 inline flatbuffers::Offset<Uint8Vector>
2744 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb,
2745                   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0)
2746 {
2747   Uint8VectorBuilder builder_(_fbb);
2748   builder_.add_values(values);
2749   return builder_.Finish();
2750 }
2751
2752 inline flatbuffers::Offset<Uint8Vector>
2753 CreateUint8VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
2754                         const std::vector<uint8_t> *values = nullptr)
2755 {
2756   if (values)
2757   {
2758     _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4);
2759   }
2760   auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
2761   return circle::CreateUint8Vector(_fbb, values__);
2762 }
2763
2764 struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2765 {
2766   typedef DimensionMetadataBuilder Builder;
2767   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2768   {
2769     VT_FORMAT = 4,
2770     VT_DENSE_SIZE = 6,
2771     VT_ARRAY_SEGMENTS_TYPE = 8,
2772     VT_ARRAY_SEGMENTS = 10,
2773     VT_ARRAY_INDICES_TYPE = 12,
2774     VT_ARRAY_INDICES = 14
2775   };
2776   circle::DimensionType format() const
2777   {
2778     return static_cast<circle::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
2779   }
2780   int32_t dense_size() const { return GetField<int32_t>(VT_DENSE_SIZE, 0); }
2781   circle::SparseIndexVector array_segments_type() const
2782   {
2783     return static_cast<circle::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
2784   }
2785   const void *array_segments() const { return GetPointer<const void *>(VT_ARRAY_SEGMENTS); }
2786   template <typename T> const T *array_segments_as() const;
2787   const circle::Int32Vector *array_segments_as_Int32Vector() const
2788   {
2789     return array_segments_type() == circle::SparseIndexVector_Int32Vector
2790              ? static_cast<const circle::Int32Vector *>(array_segments())
2791              : nullptr;
2792   }
2793   const circle::Uint16Vector *array_segments_as_Uint16Vector() const
2794   {
2795     return array_segments_type() == circle::SparseIndexVector_Uint16Vector
2796              ? static_cast<const circle::Uint16Vector *>(array_segments())
2797              : nullptr;
2798   }
2799   const circle::Uint8Vector *array_segments_as_Uint8Vector() const
2800   {
2801     return array_segments_type() == circle::SparseIndexVector_Uint8Vector
2802              ? static_cast<const circle::Uint8Vector *>(array_segments())
2803              : nullptr;
2804   }
2805   circle::SparseIndexVector array_indices_type() const
2806   {
2807     return static_cast<circle::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
2808   }
2809   const void *array_indices() const { return GetPointer<const void *>(VT_ARRAY_INDICES); }
2810   template <typename T> const T *array_indices_as() const;
2811   const circle::Int32Vector *array_indices_as_Int32Vector() const
2812   {
2813     return array_indices_type() == circle::SparseIndexVector_Int32Vector
2814              ? static_cast<const circle::Int32Vector *>(array_indices())
2815              : nullptr;
2816   }
2817   const circle::Uint16Vector *array_indices_as_Uint16Vector() const
2818   {
2819     return array_indices_type() == circle::SparseIndexVector_Uint16Vector
2820              ? static_cast<const circle::Uint16Vector *>(array_indices())
2821              : nullptr;
2822   }
2823   const circle::Uint8Vector *array_indices_as_Uint8Vector() const
2824   {
2825     return array_indices_type() == circle::SparseIndexVector_Uint8Vector
2826              ? static_cast<const circle::Uint8Vector *>(array_indices())
2827              : nullptr;
2828   }
2829   bool Verify(flatbuffers::Verifier &verifier) const
2830   {
2831     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_FORMAT) &&
2832            VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
2833            VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
2834            VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
2835            VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
2836            VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
2837            VerifyOffset(verifier, VT_ARRAY_INDICES) &&
2838            VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
2839            verifier.EndTable();
2840   }
2841 };
2842
2843 template <>
2844 inline const circle::Int32Vector *DimensionMetadata::array_segments_as<circle::Int32Vector>() const
2845 {
2846   return array_segments_as_Int32Vector();
2847 }
2848
2849 template <>
2850 inline const circle::Uint16Vector *
2851 DimensionMetadata::array_segments_as<circle::Uint16Vector>() const
2852 {
2853   return array_segments_as_Uint16Vector();
2854 }
2855
2856 template <>
2857 inline const circle::Uint8Vector *DimensionMetadata::array_segments_as<circle::Uint8Vector>() const
2858 {
2859   return array_segments_as_Uint8Vector();
2860 }
2861
2862 template <>
2863 inline const circle::Int32Vector *DimensionMetadata::array_indices_as<circle::Int32Vector>() const
2864 {
2865   return array_indices_as_Int32Vector();
2866 }
2867
2868 template <>
2869 inline const circle::Uint16Vector *DimensionMetadata::array_indices_as<circle::Uint16Vector>() const
2870 {
2871   return array_indices_as_Uint16Vector();
2872 }
2873
2874 template <>
2875 inline const circle::Uint8Vector *DimensionMetadata::array_indices_as<circle::Uint8Vector>() const
2876 {
2877   return array_indices_as_Uint8Vector();
2878 }
2879
2880 struct DimensionMetadataBuilder
2881 {
2882   typedef DimensionMetadata Table;
2883   flatbuffers::FlatBufferBuilder &fbb_;
2884   flatbuffers::uoffset_t start_;
2885   void add_format(circle::DimensionType format)
2886   {
2887     fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
2888   }
2889   void add_dense_size(int32_t dense_size)
2890   {
2891     fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
2892   }
2893   void add_array_segments_type(circle::SparseIndexVector array_segments_type)
2894   {
2895     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE,
2896                              static_cast<uint8_t>(array_segments_type), 0);
2897   }
2898   void add_array_segments(flatbuffers::Offset<void> array_segments)
2899   {
2900     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
2901   }
2902   void add_array_indices_type(circle::SparseIndexVector array_indices_type)
2903   {
2904     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE,
2905                              static_cast<uint8_t>(array_indices_type), 0);
2906   }
2907   void add_array_indices(flatbuffers::Offset<void> array_indices)
2908   {
2909     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
2910   }
2911   explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2912   {
2913     start_ = fbb_.StartTable();
2914   }
2915   DimensionMetadataBuilder &operator=(const DimensionMetadataBuilder &);
2916   flatbuffers::Offset<DimensionMetadata> Finish()
2917   {
2918     const auto end = fbb_.EndTable(start_);
2919     auto o = flatbuffers::Offset<DimensionMetadata>(end);
2920     return o;
2921   }
2922 };
2923
2924 inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
2925   flatbuffers::FlatBufferBuilder &_fbb, circle::DimensionType format = circle::DimensionType_DENSE,
2926   int32_t dense_size = 0,
2927   circle::SparseIndexVector array_segments_type = circle::SparseIndexVector_NONE,
2928   flatbuffers::Offset<void> array_segments = 0,
2929   circle::SparseIndexVector array_indices_type = circle::SparseIndexVector_NONE,
2930   flatbuffers::Offset<void> array_indices = 0)
2931 {
2932   DimensionMetadataBuilder builder_(_fbb);
2933   builder_.add_array_indices(array_indices);
2934   builder_.add_array_segments(array_segments);
2935   builder_.add_dense_size(dense_size);
2936   builder_.add_array_indices_type(array_indices_type);
2937   builder_.add_array_segments_type(array_segments_type);
2938   builder_.add_format(format);
2939   return builder_.Finish();
2940 }
2941
2942 struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
2943 {
2944   typedef SparsityParametersBuilder Builder;
2945   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
2946   {
2947     VT_TRAVERSAL_ORDER = 4,
2948     VT_BLOCK_MAP = 6,
2949     VT_DIM_METADATA = 8
2950   };
2951   const flatbuffers::Vector<int32_t> *traversal_order() const
2952   {
2953     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
2954   }
2955   const flatbuffers::Vector<int32_t> *block_map() const
2956   {
2957     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
2958   }
2959   const flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>> *dim_metadata() const
2960   {
2961     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>> *>(
2962       VT_DIM_METADATA);
2963   }
2964   bool Verify(flatbuffers::Verifier &verifier) const
2965   {
2966     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
2967            verifier.VerifyVector(traversal_order()) && VerifyOffset(verifier, VT_BLOCK_MAP) &&
2968            verifier.VerifyVector(block_map()) && VerifyOffset(verifier, VT_DIM_METADATA) &&
2969            verifier.VerifyVector(dim_metadata()) && verifier.VerifyVectorOfTables(dim_metadata()) &&
2970            verifier.EndTable();
2971   }
2972 };
2973
2974 struct SparsityParametersBuilder
2975 {
2976   typedef SparsityParameters Table;
2977   flatbuffers::FlatBufferBuilder &fbb_;
2978   flatbuffers::uoffset_t start_;
2979   void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order)
2980   {
2981     fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
2982   }
2983   void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map)
2984   {
2985     fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
2986   }
2987   void add_dim_metadata(
2988     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>>>
2989       dim_metadata)
2990   {
2991     fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
2992   }
2993   explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
2994   {
2995     start_ = fbb_.StartTable();
2996   }
2997   SparsityParametersBuilder &operator=(const SparsityParametersBuilder &);
2998   flatbuffers::Offset<SparsityParameters> Finish()
2999   {
3000     const auto end = fbb_.EndTable(start_);
3001     auto o = flatbuffers::Offset<SparsityParameters>(end);
3002     return o;
3003   }
3004 };
3005
3006 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
3007   flatbuffers::FlatBufferBuilder &_fbb,
3008   flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
3009   flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
3010   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>>>
3011     dim_metadata = 0)
3012 {
3013   SparsityParametersBuilder builder_(_fbb);
3014   builder_.add_dim_metadata(dim_metadata);
3015   builder_.add_block_map(block_map);
3016   builder_.add_traversal_order(traversal_order);
3017   return builder_.Finish();
3018 }
3019
3020 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
3021   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *traversal_order = nullptr,
3022   const std::vector<int32_t> *block_map = nullptr,
3023   const std::vector<flatbuffers::Offset<circle::DimensionMetadata>> *dim_metadata = nullptr)
3024 {
3025   auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
3026   auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
3027   auto dim_metadata__ =
3028     dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<circle::DimensionMetadata>>(*dim_metadata)
3029                  : 0;
3030   return circle::CreateSparsityParameters(_fbb, traversal_order__, block_map__, dim_metadata__);
3031 }
3032
3033 struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3034 {
3035   typedef TensorBuilder Builder;
3036   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3037   {
3038     VT_SHAPE = 4,
3039     VT_TYPE = 6,
3040     VT_BUFFER = 8,
3041     VT_NAME = 10,
3042     VT_QUANTIZATION = 12,
3043     VT_IS_VARIABLE = 14,
3044     VT_SPARSITY = 16,
3045     VT_SHAPE_SIGNATURE = 18
3046   };
3047   const flatbuffers::Vector<int32_t> *shape() const
3048   {
3049     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
3050   }
3051   circle::TensorType type() const
3052   {
3053     return static_cast<circle::TensorType>(GetField<int8_t>(VT_TYPE, 0));
3054   }
3055   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
3056   const flatbuffers::String *name() const
3057   {
3058     return GetPointer<const flatbuffers::String *>(VT_NAME);
3059   }
3060   const circle::QuantizationParameters *quantization() const
3061   {
3062     return GetPointer<const circle::QuantizationParameters *>(VT_QUANTIZATION);
3063   }
3064   bool is_variable() const { return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0; }
3065   const circle::SparsityParameters *sparsity() const
3066   {
3067     return GetPointer<const circle::SparsityParameters *>(VT_SPARSITY);
3068   }
3069   const flatbuffers::Vector<int32_t> *shape_signature() const
3070   {
3071     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
3072   }
3073   bool Verify(flatbuffers::Verifier &verifier) const
3074   {
3075     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) &&
3076            verifier.VerifyVector(shape()) && VerifyField<int8_t>(verifier, VT_TYPE) &&
3077            VerifyField<uint32_t>(verifier, VT_BUFFER) && VerifyOffset(verifier, VT_NAME) &&
3078            verifier.VerifyString(name()) && VerifyOffset(verifier, VT_QUANTIZATION) &&
3079            verifier.VerifyTable(quantization()) && VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
3080            VerifyOffset(verifier, VT_SPARSITY) && verifier.VerifyTable(sparsity()) &&
3081            VerifyOffset(verifier, VT_SHAPE_SIGNATURE) && verifier.VerifyVector(shape_signature()) &&
3082            verifier.EndTable();
3083   }
3084 };
3085
3086 struct TensorBuilder
3087 {
3088   typedef Tensor Table;
3089   flatbuffers::FlatBufferBuilder &fbb_;
3090   flatbuffers::uoffset_t start_;
3091   void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape)
3092   {
3093     fbb_.AddOffset(Tensor::VT_SHAPE, shape);
3094   }
3095   void add_type(circle::TensorType type)
3096   {
3097     fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
3098   }
3099   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0); }
3100   void add_name(flatbuffers::Offset<flatbuffers::String> name)
3101   {
3102     fbb_.AddOffset(Tensor::VT_NAME, name);
3103   }
3104   void add_quantization(flatbuffers::Offset<circle::QuantizationParameters> quantization)
3105   {
3106     fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
3107   }
3108   void add_is_variable(bool is_variable)
3109   {
3110     fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
3111   }
3112   void add_sparsity(flatbuffers::Offset<circle::SparsityParameters> sparsity)
3113   {
3114     fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
3115   }
3116   void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature)
3117   {
3118     fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
3119   }
3120   explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3121   {
3122     start_ = fbb_.StartTable();
3123   }
3124   TensorBuilder &operator=(const TensorBuilder &);
3125   flatbuffers::Offset<Tensor> Finish()
3126   {
3127     const auto end = fbb_.EndTable(start_);
3128     auto o = flatbuffers::Offset<Tensor>(end);
3129     return o;
3130   }
3131 };
3132
3133 inline flatbuffers::Offset<Tensor>
3134 CreateTensor(flatbuffers::FlatBufferBuilder &_fbb,
3135              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
3136              circle::TensorType type = circle::TensorType_FLOAT32, uint32_t buffer = 0,
3137              flatbuffers::Offset<flatbuffers::String> name = 0,
3138              flatbuffers::Offset<circle::QuantizationParameters> quantization = 0,
3139              bool is_variable = false, flatbuffers::Offset<circle::SparsityParameters> sparsity = 0,
3140              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0)
3141 {
3142   TensorBuilder builder_(_fbb);
3143   builder_.add_shape_signature(shape_signature);
3144   builder_.add_sparsity(sparsity);
3145   builder_.add_quantization(quantization);
3146   builder_.add_name(name);
3147   builder_.add_buffer(buffer);
3148   builder_.add_shape(shape);
3149   builder_.add_is_variable(is_variable);
3150   builder_.add_type(type);
3151   return builder_.Finish();
3152 }
3153
3154 inline flatbuffers::Offset<Tensor> CreateTensorDirect(
3155   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *shape = nullptr,
3156   circle::TensorType type = circle::TensorType_FLOAT32, uint32_t buffer = 0,
3157   const char *name = nullptr, flatbuffers::Offset<circle::QuantizationParameters> quantization = 0,
3158   bool is_variable = false, flatbuffers::Offset<circle::SparsityParameters> sparsity = 0,
3159   const std::vector<int32_t> *shape_signature = nullptr)
3160 {
3161   auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
3162   auto name__ = name ? _fbb.CreateString(name) : 0;
3163   auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
3164   return circle::CreateTensor(_fbb, shape__, type, buffer, name__, quantization, is_variable,
3165                               sparsity, shape_signature__);
3166 }
3167
3168 struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3169 {
3170   typedef Conv2DOptionsBuilder Builder;
3171   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3172   {
3173     VT_PADDING = 4,
3174     VT_STRIDE_W = 6,
3175     VT_STRIDE_H = 8,
3176     VT_FUSED_ACTIVATION_FUNCTION = 10,
3177     VT_DILATION_W_FACTOR = 12,
3178     VT_DILATION_H_FACTOR = 14
3179   };
3180   circle::Padding padding() const
3181   {
3182     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
3183   }
3184   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3185   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3186   circle::ActivationFunctionType fused_activation_function() const
3187   {
3188     return static_cast<circle::ActivationFunctionType>(
3189       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3190   }
3191   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
3192   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
3193   bool Verify(flatbuffers::Verifier &verifier) const
3194   {
3195     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3196            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3197            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3198            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3199            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3200            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
3201   }
3202 };
3203
3204 struct Conv2DOptionsBuilder
3205 {
3206   typedef Conv2DOptions Table;
3207   flatbuffers::FlatBufferBuilder &fbb_;
3208   flatbuffers::uoffset_t start_;
3209   void add_padding(circle::Padding padding)
3210   {
3211     fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3212   }
3213   void add_stride_w(int32_t stride_w)
3214   {
3215     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
3216   }
3217   void add_stride_h(int32_t stride_h)
3218   {
3219     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
3220   }
3221   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3222   {
3223     fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3224                             static_cast<int8_t>(fused_activation_function), 0);
3225   }
3226   void add_dilation_w_factor(int32_t dilation_w_factor)
3227   {
3228     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
3229   }
3230   void add_dilation_h_factor(int32_t dilation_h_factor)
3231   {
3232     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
3233   }
3234   explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3235   {
3236     start_ = fbb_.StartTable();
3237   }
3238   Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &);
3239   flatbuffers::Offset<Conv2DOptions> Finish()
3240   {
3241     const auto end = fbb_.EndTable(start_);
3242     auto o = flatbuffers::Offset<Conv2DOptions>(end);
3243     return o;
3244   }
3245 };
3246
3247 inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
3248   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
3249   int32_t stride_w = 0, int32_t stride_h = 0,
3250   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3251   int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
3252 {
3253   Conv2DOptionsBuilder builder_(_fbb);
3254   builder_.add_dilation_h_factor(dilation_h_factor);
3255   builder_.add_dilation_w_factor(dilation_w_factor);
3256   builder_.add_stride_h(stride_h);
3257   builder_.add_stride_w(stride_w);
3258   builder_.add_fused_activation_function(fused_activation_function);
3259   builder_.add_padding(padding);
3260   return builder_.Finish();
3261 }
3262
3263 struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3264 {
3265   typedef Pool2DOptionsBuilder Builder;
3266   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3267   {
3268     VT_PADDING = 4,
3269     VT_STRIDE_W = 6,
3270     VT_STRIDE_H = 8,
3271     VT_FILTER_WIDTH = 10,
3272     VT_FILTER_HEIGHT = 12,
3273     VT_FUSED_ACTIVATION_FUNCTION = 14
3274   };
3275   circle::Padding padding() const
3276   {
3277     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
3278   }
3279   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3280   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3281   int32_t filter_width() const { return GetField<int32_t>(VT_FILTER_WIDTH, 0); }
3282   int32_t filter_height() const { return GetField<int32_t>(VT_FILTER_HEIGHT, 0); }
3283   circle::ActivationFunctionType fused_activation_function() const
3284   {
3285     return static_cast<circle::ActivationFunctionType>(
3286       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3287   }
3288   bool Verify(flatbuffers::Verifier &verifier) const
3289   {
3290     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3291            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3292            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3293            VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
3294            VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
3295            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
3296   }
3297 };
3298
3299 struct Pool2DOptionsBuilder
3300 {
3301   typedef Pool2DOptions Table;
3302   flatbuffers::FlatBufferBuilder &fbb_;
3303   flatbuffers::uoffset_t start_;
3304   void add_padding(circle::Padding padding)
3305   {
3306     fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3307   }
3308   void add_stride_w(int32_t stride_w)
3309   {
3310     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
3311   }
3312   void add_stride_h(int32_t stride_h)
3313   {
3314     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
3315   }
3316   void add_filter_width(int32_t filter_width)
3317   {
3318     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
3319   }
3320   void add_filter_height(int32_t filter_height)
3321   {
3322     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
3323   }
3324   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3325   {
3326     fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3327                             static_cast<int8_t>(fused_activation_function), 0);
3328   }
3329   explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3330   {
3331     start_ = fbb_.StartTable();
3332   }
3333   Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &);
3334   flatbuffers::Offset<Pool2DOptions> Finish()
3335   {
3336     const auto end = fbb_.EndTable(start_);
3337     auto o = flatbuffers::Offset<Pool2DOptions>(end);
3338     return o;
3339   }
3340 };
3341
3342 inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
3343   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
3344   int32_t stride_w = 0, int32_t stride_h = 0, int32_t filter_width = 0, int32_t filter_height = 0,
3345   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
3346 {
3347   Pool2DOptionsBuilder builder_(_fbb);
3348   builder_.add_filter_height(filter_height);
3349   builder_.add_filter_width(filter_width);
3350   builder_.add_stride_h(stride_h);
3351   builder_.add_stride_w(stride_w);
3352   builder_.add_fused_activation_function(fused_activation_function);
3353   builder_.add_padding(padding);
3354   return builder_.Finish();
3355 }
3356
3357 struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3358 {
3359   typedef DepthwiseConv2DOptionsBuilder Builder;
3360   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3361   {
3362     VT_PADDING = 4,
3363     VT_STRIDE_W = 6,
3364     VT_STRIDE_H = 8,
3365     VT_DEPTH_MULTIPLIER = 10,
3366     VT_FUSED_ACTIVATION_FUNCTION = 12,
3367     VT_DILATION_W_FACTOR = 14,
3368     VT_DILATION_H_FACTOR = 16
3369   };
3370   circle::Padding padding() const
3371   {
3372     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
3373   }
3374   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
3375   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
3376   int32_t depth_multiplier() const { return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0); }
3377   circle::ActivationFunctionType fused_activation_function() const
3378   {
3379     return static_cast<circle::ActivationFunctionType>(
3380       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3381   }
3382   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
3383   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
3384   bool Verify(flatbuffers::Verifier &verifier) const
3385   {
3386     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
3387            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
3388            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
3389            VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
3390            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3391            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
3392            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
3393   }
3394 };
3395
3396 struct DepthwiseConv2DOptionsBuilder
3397 {
3398   typedef DepthwiseConv2DOptions Table;
3399   flatbuffers::FlatBufferBuilder &fbb_;
3400   flatbuffers::uoffset_t start_;
3401   void add_padding(circle::Padding padding)
3402   {
3403     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
3404   }
3405   void add_stride_w(int32_t stride_w)
3406   {
3407     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
3408   }
3409   void add_stride_h(int32_t stride_h)
3410   {
3411     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
3412   }
3413   void add_depth_multiplier(int32_t depth_multiplier)
3414   {
3415     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
3416   }
3417   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3418   {
3419     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
3420                             static_cast<int8_t>(fused_activation_function), 0);
3421   }
3422   void add_dilation_w_factor(int32_t dilation_w_factor)
3423   {
3424     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
3425   }
3426   void add_dilation_h_factor(int32_t dilation_h_factor)
3427   {
3428     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
3429   }
3430   explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3431   {
3432     start_ = fbb_.StartTable();
3433   }
3434   DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &);
3435   flatbuffers::Offset<DepthwiseConv2DOptions> Finish()
3436   {
3437     const auto end = fbb_.EndTable(start_);
3438     auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
3439     return o;
3440   }
3441 };
3442
3443 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
3444   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
3445   int32_t stride_w = 0, int32_t stride_h = 0, int32_t depth_multiplier = 0,
3446   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3447   int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
3448 {
3449   DepthwiseConv2DOptionsBuilder builder_(_fbb);
3450   builder_.add_dilation_h_factor(dilation_h_factor);
3451   builder_.add_dilation_w_factor(dilation_w_factor);
3452   builder_.add_depth_multiplier(depth_multiplier);
3453   builder_.add_stride_h(stride_h);
3454   builder_.add_stride_w(stride_w);
3455   builder_.add_fused_activation_function(fused_activation_function);
3456   builder_.add_padding(padding);
3457   return builder_.Finish();
3458 }
3459
3460 struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3461 {
3462   typedef ConcatEmbeddingsOptionsBuilder Builder;
3463   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3464   {
3465     VT_NUM_CHANNELS = 4,
3466     VT_NUM_COLUMNS_PER_CHANNEL = 6,
3467     VT_EMBEDDING_DIM_PER_CHANNEL = 8
3468   };
3469   int32_t num_channels() const { return GetField<int32_t>(VT_NUM_CHANNELS, 0); }
3470   const flatbuffers::Vector<int32_t> *num_columns_per_channel() const
3471   {
3472     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
3473   }
3474   const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const
3475   {
3476     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
3477   }
3478   bool Verify(flatbuffers::Verifier &verifier) const
3479   {
3480     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
3481            VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
3482            verifier.VerifyVector(num_columns_per_channel()) &&
3483            VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
3484            verifier.VerifyVector(embedding_dim_per_channel()) && verifier.EndTable();
3485   }
3486 };
3487
3488 struct ConcatEmbeddingsOptionsBuilder
3489 {
3490   typedef ConcatEmbeddingsOptions Table;
3491   flatbuffers::FlatBufferBuilder &fbb_;
3492   flatbuffers::uoffset_t start_;
3493   void add_num_channels(int32_t num_channels)
3494   {
3495     fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
3496   }
3497   void add_num_columns_per_channel(
3498     flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel)
3499   {
3500     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
3501   }
3502   void add_embedding_dim_per_channel(
3503     flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel)
3504   {
3505     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL,
3506                    embedding_dim_per_channel);
3507   }
3508   explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3509   {
3510     start_ = fbb_.StartTable();
3511   }
3512   ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &);
3513   flatbuffers::Offset<ConcatEmbeddingsOptions> Finish()
3514   {
3515     const auto end = fbb_.EndTable(start_);
3516     auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
3517     return o;
3518   }
3519 };
3520
3521 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
3522   flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
3523   flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
3524   flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0)
3525 {
3526   ConcatEmbeddingsOptionsBuilder builder_(_fbb);
3527   builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
3528   builder_.add_num_columns_per_channel(num_columns_per_channel);
3529   builder_.add_num_channels(num_channels);
3530   return builder_.Finish();
3531 }
3532
3533 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
3534 CreateConcatEmbeddingsOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
3535                                     const std::vector<int32_t> *num_columns_per_channel = nullptr,
3536                                     const std::vector<int32_t> *embedding_dim_per_channel = nullptr)
3537 {
3538   auto num_columns_per_channel__ =
3539     num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
3540   auto embedding_dim_per_channel__ =
3541     embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
3542   return circle::CreateConcatEmbeddingsOptions(_fbb, num_channels, num_columns_per_channel__,
3543                                                embedding_dim_per_channel__);
3544 }
3545
3546 struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3547 {
3548   typedef LSHProjectionOptionsBuilder Builder;
3549   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3550   {
3551     VT_TYPE = 4
3552   };
3553   circle::LSHProjectionType type() const
3554   {
3555     return static_cast<circle::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
3556   }
3557   bool Verify(flatbuffers::Verifier &verifier) const
3558   {
3559     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_TYPE) &&
3560            verifier.EndTable();
3561   }
3562 };
3563
3564 struct LSHProjectionOptionsBuilder
3565 {
3566   typedef LSHProjectionOptions Table;
3567   flatbuffers::FlatBufferBuilder &fbb_;
3568   flatbuffers::uoffset_t start_;
3569   void add_type(circle::LSHProjectionType type)
3570   {
3571     fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
3572   }
3573   explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3574   {
3575     start_ = fbb_.StartTable();
3576   }
3577   LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &);
3578   flatbuffers::Offset<LSHProjectionOptions> Finish()
3579   {
3580     const auto end = fbb_.EndTable(start_);
3581     auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
3582     return o;
3583   }
3584 };
3585
3586 inline flatbuffers::Offset<LSHProjectionOptions>
3587 CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb,
3588                            circle::LSHProjectionType type = circle::LSHProjectionType_UNKNOWN)
3589 {
3590   LSHProjectionOptionsBuilder builder_(_fbb);
3591   builder_.add_type(type);
3592   return builder_.Finish();
3593 }
3594
3595 struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3596 {
3597   typedef SVDFOptionsBuilder Builder;
3598   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3599   {
3600     VT_RANK = 4,
3601     VT_FUSED_ACTIVATION_FUNCTION = 6,
3602     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3603   };
3604   int32_t rank() const { return GetField<int32_t>(VT_RANK, 0); }
3605   circle::ActivationFunctionType fused_activation_function() const
3606   {
3607     return static_cast<circle::ActivationFunctionType>(
3608       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3609   }
3610   bool asymmetric_quantize_inputs() const
3611   {
3612     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3613   }
3614   bool Verify(flatbuffers::Verifier &verifier) const
3615   {
3616     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RANK) &&
3617            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3618            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3619   }
3620 };
3621
3622 struct SVDFOptionsBuilder
3623 {
3624   typedef SVDFOptions Table;
3625   flatbuffers::FlatBufferBuilder &fbb_;
3626   flatbuffers::uoffset_t start_;
3627   void add_rank(int32_t rank) { fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0); }
3628   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3629   {
3630     fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION,
3631                             static_cast<int8_t>(fused_activation_function), 0);
3632   }
3633   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3634   {
3635     fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3636                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3637   }
3638   explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3639   {
3640     start_ = fbb_.StartTable();
3641   }
3642   SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &);
3643   flatbuffers::Offset<SVDFOptions> Finish()
3644   {
3645     const auto end = fbb_.EndTable(start_);
3646     auto o = flatbuffers::Offset<SVDFOptions>(end);
3647     return o;
3648   }
3649 };
3650
3651 inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
3652   flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0,
3653   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3654   bool asymmetric_quantize_inputs = false)
3655 {
3656   SVDFOptionsBuilder builder_(_fbb);
3657   builder_.add_rank(rank);
3658   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3659   builder_.add_fused_activation_function(fused_activation_function);
3660   return builder_.Finish();
3661 }
3662
3663 struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3664 {
3665   typedef RNNOptionsBuilder Builder;
3666   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3667   {
3668     VT_FUSED_ACTIVATION_FUNCTION = 4,
3669     VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
3670   };
3671   circle::ActivationFunctionType fused_activation_function() const
3672   {
3673     return static_cast<circle::ActivationFunctionType>(
3674       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3675   }
3676   bool asymmetric_quantize_inputs() const
3677   {
3678     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3679   }
3680   bool Verify(flatbuffers::Verifier &verifier) const
3681   {
3682     return VerifyTableStart(verifier) &&
3683            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3684            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3685   }
3686 };
3687
3688 struct RNNOptionsBuilder
3689 {
3690   typedef RNNOptions Table;
3691   flatbuffers::FlatBufferBuilder &fbb_;
3692   flatbuffers::uoffset_t start_;
3693   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3694   {
3695     fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3696                             static_cast<int8_t>(fused_activation_function), 0);
3697   }
3698   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3699   {
3700     fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3701                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3702   }
3703   explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3704   {
3705     start_ = fbb_.StartTable();
3706   }
3707   RNNOptionsBuilder &operator=(const RNNOptionsBuilder &);
3708   flatbuffers::Offset<RNNOptions> Finish()
3709   {
3710     const auto end = fbb_.EndTable(start_);
3711     auto o = flatbuffers::Offset<RNNOptions>(end);
3712     return o;
3713   }
3714 };
3715
3716 inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
3717   flatbuffers::FlatBufferBuilder &_fbb,
3718   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3719   bool asymmetric_quantize_inputs = false)
3720 {
3721   RNNOptionsBuilder builder_(_fbb);
3722   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3723   builder_.add_fused_activation_function(fused_activation_function);
3724   return builder_.Finish();
3725 }
3726
3727 struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3728 {
3729   typedef SequenceRNNOptionsBuilder Builder;
3730   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3731   {
3732     VT_TIME_MAJOR = 4,
3733     VT_FUSED_ACTIVATION_FUNCTION = 6,
3734     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
3735   };
3736   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3737   circle::ActivationFunctionType fused_activation_function() const
3738   {
3739     return static_cast<circle::ActivationFunctionType>(
3740       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3741   }
3742   bool asymmetric_quantize_inputs() const
3743   {
3744     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3745   }
3746   bool Verify(flatbuffers::Verifier &verifier) const
3747   {
3748     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3749            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3750            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3751   }
3752 };
3753
3754 struct SequenceRNNOptionsBuilder
3755 {
3756   typedef SequenceRNNOptions Table;
3757   flatbuffers::FlatBufferBuilder &fbb_;
3758   flatbuffers::uoffset_t start_;
3759   void add_time_major(bool time_major)
3760   {
3761     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major),
3762                              0);
3763   }
3764   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3765   {
3766     fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3767                             static_cast<int8_t>(fused_activation_function), 0);
3768   }
3769   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3770   {
3771     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3772                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3773   }
3774   explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3775   {
3776     start_ = fbb_.StartTable();
3777   }
3778   SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &);
3779   flatbuffers::Offset<SequenceRNNOptions> Finish()
3780   {
3781     const auto end = fbb_.EndTable(start_);
3782     auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
3783     return o;
3784   }
3785 };
3786
3787 inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
3788   flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3789   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3790   bool asymmetric_quantize_inputs = false)
3791 {
3792   SequenceRNNOptionsBuilder builder_(_fbb);
3793   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3794   builder_.add_fused_activation_function(fused_activation_function);
3795   builder_.add_time_major(time_major);
3796   return builder_.Finish();
3797 }
3798
3799 struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3800 {
3801   typedef BidirectionalSequenceRNNOptionsBuilder Builder;
3802   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3803   {
3804     VT_TIME_MAJOR = 4,
3805     VT_FUSED_ACTIVATION_FUNCTION = 6,
3806     VT_MERGE_OUTPUTS = 8,
3807     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3808   };
3809   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
3810   circle::ActivationFunctionType fused_activation_function() const
3811   {
3812     return static_cast<circle::ActivationFunctionType>(
3813       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3814   }
3815   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
3816   bool asymmetric_quantize_inputs() const
3817   {
3818     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3819   }
3820   bool Verify(flatbuffers::Verifier &verifier) const
3821   {
3822     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
3823            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3824            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
3825            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3826   }
3827 };
3828
3829 struct BidirectionalSequenceRNNOptionsBuilder
3830 {
3831   typedef BidirectionalSequenceRNNOptions Table;
3832   flatbuffers::FlatBufferBuilder &fbb_;
3833   flatbuffers::uoffset_t start_;
3834   void add_time_major(bool time_major)
3835   {
3836     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR,
3837                              static_cast<uint8_t>(time_major), 0);
3838   }
3839   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3840   {
3841     fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
3842                             static_cast<int8_t>(fused_activation_function), 0);
3843   }
3844   void add_merge_outputs(bool merge_outputs)
3845   {
3846     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS,
3847                              static_cast<uint8_t>(merge_outputs), 0);
3848   }
3849   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3850   {
3851     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3852                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3853   }
3854   explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3855   {
3856     start_ = fbb_.StartTable();
3857   }
3858   BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &);
3859   flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish()
3860   {
3861     const auto end = fbb_.EndTable(start_);
3862     auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
3863     return o;
3864   }
3865 };
3866
3867 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
3868   flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
3869   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3870   bool merge_outputs = false, bool asymmetric_quantize_inputs = false)
3871 {
3872   BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
3873   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3874   builder_.add_merge_outputs(merge_outputs);
3875   builder_.add_fused_activation_function(fused_activation_function);
3876   builder_.add_time_major(time_major);
3877   return builder_.Finish();
3878 }
3879
3880 struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3881 {
3882   typedef FullyConnectedOptionsBuilder Builder;
3883   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3884   {
3885     VT_FUSED_ACTIVATION_FUNCTION = 4,
3886     VT_WEIGHTS_FORMAT = 6,
3887     VT_KEEP_NUM_DIMS = 8,
3888     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
3889   };
3890   circle::ActivationFunctionType fused_activation_function() const
3891   {
3892     return static_cast<circle::ActivationFunctionType>(
3893       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
3894   }
3895   circle::FullyConnectedOptionsWeightsFormat weights_format() const
3896   {
3897     return static_cast<circle::FullyConnectedOptionsWeightsFormat>(
3898       GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
3899   }
3900   bool keep_num_dims() const { return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0; }
3901   bool asymmetric_quantize_inputs() const
3902   {
3903     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
3904   }
3905   bool Verify(flatbuffers::Verifier &verifier) const
3906   {
3907     return VerifyTableStart(verifier) &&
3908            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
3909            VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
3910            VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
3911            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
3912   }
3913 };
3914
3915 struct FullyConnectedOptionsBuilder
3916 {
3917   typedef FullyConnectedOptions Table;
3918   flatbuffers::FlatBufferBuilder &fbb_;
3919   flatbuffers::uoffset_t start_;
3920   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
3921   {
3922     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
3923                             static_cast<int8_t>(fused_activation_function), 0);
3924   }
3925   void add_weights_format(circle::FullyConnectedOptionsWeightsFormat weights_format)
3926   {
3927     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT,
3928                             static_cast<int8_t>(weights_format), 0);
3929   }
3930   void add_keep_num_dims(bool keep_num_dims)
3931   {
3932     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS,
3933                              static_cast<uint8_t>(keep_num_dims), 0);
3934   }
3935   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
3936   {
3937     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
3938                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
3939   }
3940   explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3941   {
3942     start_ = fbb_.StartTable();
3943   }
3944   FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &);
3945   flatbuffers::Offset<FullyConnectedOptions> Finish()
3946   {
3947     const auto end = fbb_.EndTable(start_);
3948     auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
3949     return o;
3950   }
3951 };
3952
3953 inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
3954   flatbuffers::FlatBufferBuilder &_fbb,
3955   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
3956   circle::FullyConnectedOptionsWeightsFormat weights_format =
3957     circle::FullyConnectedOptionsWeightsFormat_DEFAULT,
3958   bool keep_num_dims = false, bool asymmetric_quantize_inputs = false)
3959 {
3960   FullyConnectedOptionsBuilder builder_(_fbb);
3961   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
3962   builder_.add_keep_num_dims(keep_num_dims);
3963   builder_.add_weights_format(weights_format);
3964   builder_.add_fused_activation_function(fused_activation_function);
3965   return builder_.Finish();
3966 }
3967
3968 struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
3969 {
3970   typedef SoftmaxOptionsBuilder Builder;
3971   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
3972   {
3973     VT_BETA = 4
3974   };
3975   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
3976   bool Verify(flatbuffers::Verifier &verifier) const
3977   {
3978     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_BETA) &&
3979            verifier.EndTable();
3980   }
3981 };
3982
3983 struct SoftmaxOptionsBuilder
3984 {
3985   typedef SoftmaxOptions Table;
3986   flatbuffers::FlatBufferBuilder &fbb_;
3987   flatbuffers::uoffset_t start_;
3988   void add_beta(float beta) { fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f); }
3989   explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
3990   {
3991     start_ = fbb_.StartTable();
3992   }
3993   SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &);
3994   flatbuffers::Offset<SoftmaxOptions> Finish()
3995   {
3996     const auto end = fbb_.EndTable(start_);
3997     auto o = flatbuffers::Offset<SoftmaxOptions>(end);
3998     return o;
3999   }
4000 };
4001
4002 inline flatbuffers::Offset<SoftmaxOptions>
4003 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f)
4004 {
4005   SoftmaxOptionsBuilder builder_(_fbb);
4006   builder_.add_beta(beta);
4007   return builder_.Finish();
4008 }
4009
4010 struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4011 {
4012   typedef ConcatenationOptionsBuilder Builder;
4013   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4014   {
4015     VT_AXIS = 4,
4016     VT_FUSED_ACTIVATION_FUNCTION = 6
4017   };
4018   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
4019   circle::ActivationFunctionType fused_activation_function() const
4020   {
4021     return static_cast<circle::ActivationFunctionType>(
4022       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4023   }
4024   bool Verify(flatbuffers::Verifier &verifier) const
4025   {
4026     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
4027            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4028   }
4029 };
4030
4031 struct ConcatenationOptionsBuilder
4032 {
4033   typedef ConcatenationOptions Table;
4034   flatbuffers::FlatBufferBuilder &fbb_;
4035   flatbuffers::uoffset_t start_;
4036   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0); }
4037   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4038   {
4039     fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION,
4040                             static_cast<int8_t>(fused_activation_function), 0);
4041   }
4042   explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4043   {
4044     start_ = fbb_.StartTable();
4045   }
4046   ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &);
4047   flatbuffers::Offset<ConcatenationOptions> Finish()
4048   {
4049     const auto end = fbb_.EndTable(start_);
4050     auto o = flatbuffers::Offset<ConcatenationOptions>(end);
4051     return o;
4052   }
4053 };
4054
4055 inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
4056   flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0,
4057   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
4058 {
4059   ConcatenationOptionsBuilder builder_(_fbb);
4060   builder_.add_axis(axis);
4061   builder_.add_fused_activation_function(fused_activation_function);
4062   return builder_.Finish();
4063 }
4064
4065 struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4066 {
4067   typedef AddOptionsBuilder Builder;
4068   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4069   {
4070     VT_FUSED_ACTIVATION_FUNCTION = 4
4071   };
4072   circle::ActivationFunctionType fused_activation_function() const
4073   {
4074     return static_cast<circle::ActivationFunctionType>(
4075       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4076   }
4077   bool Verify(flatbuffers::Verifier &verifier) const
4078   {
4079     return VerifyTableStart(verifier) &&
4080            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4081   }
4082 };
4083
4084 struct AddOptionsBuilder
4085 {
4086   typedef AddOptions Table;
4087   flatbuffers::FlatBufferBuilder &fbb_;
4088   flatbuffers::uoffset_t start_;
4089   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4090   {
4091     fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION,
4092                             static_cast<int8_t>(fused_activation_function), 0);
4093   }
4094   explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4095   {
4096     start_ = fbb_.StartTable();
4097   }
4098   AddOptionsBuilder &operator=(const AddOptionsBuilder &);
4099   flatbuffers::Offset<AddOptions> Finish()
4100   {
4101     const auto end = fbb_.EndTable(start_);
4102     auto o = flatbuffers::Offset<AddOptions>(end);
4103     return o;
4104   }
4105 };
4106
4107 inline flatbuffers::Offset<AddOptions> CreateAddOptions(
4108   flatbuffers::FlatBufferBuilder &_fbb,
4109   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
4110 {
4111   AddOptionsBuilder builder_(_fbb);
4112   builder_.add_fused_activation_function(fused_activation_function);
4113   return builder_.Finish();
4114 }
4115
4116 struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4117 {
4118   typedef MulOptionsBuilder Builder;
4119   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4120   {
4121     VT_FUSED_ACTIVATION_FUNCTION = 4
4122   };
4123   circle::ActivationFunctionType fused_activation_function() const
4124   {
4125     return static_cast<circle::ActivationFunctionType>(
4126       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4127   }
4128   bool Verify(flatbuffers::Verifier &verifier) const
4129   {
4130     return VerifyTableStart(verifier) &&
4131            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4132   }
4133 };
4134
4135 struct MulOptionsBuilder
4136 {
4137   typedef MulOptions Table;
4138   flatbuffers::FlatBufferBuilder &fbb_;
4139   flatbuffers::uoffset_t start_;
4140   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4141   {
4142     fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION,
4143                             static_cast<int8_t>(fused_activation_function), 0);
4144   }
4145   explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4146   {
4147     start_ = fbb_.StartTable();
4148   }
4149   MulOptionsBuilder &operator=(const MulOptionsBuilder &);
4150   flatbuffers::Offset<MulOptions> Finish()
4151   {
4152     const auto end = fbb_.EndTable(start_);
4153     auto o = flatbuffers::Offset<MulOptions>(end);
4154     return o;
4155   }
4156 };
4157
4158 inline flatbuffers::Offset<MulOptions> CreateMulOptions(
4159   flatbuffers::FlatBufferBuilder &_fbb,
4160   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
4161 {
4162   MulOptionsBuilder builder_(_fbb);
4163   builder_.add_fused_activation_function(fused_activation_function);
4164   return builder_.Finish();
4165 }
4166
4167 struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4168 {
4169   typedef L2NormOptionsBuilder Builder;
4170   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4171   {
4172     VT_FUSED_ACTIVATION_FUNCTION = 4
4173   };
4174   circle::ActivationFunctionType fused_activation_function() const
4175   {
4176     return static_cast<circle::ActivationFunctionType>(
4177       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4178   }
4179   bool Verify(flatbuffers::Verifier &verifier) const
4180   {
4181     return VerifyTableStart(verifier) &&
4182            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
4183   }
4184 };
4185
4186 struct L2NormOptionsBuilder
4187 {
4188   typedef L2NormOptions Table;
4189   flatbuffers::FlatBufferBuilder &fbb_;
4190   flatbuffers::uoffset_t start_;
4191   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4192   {
4193     fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION,
4194                             static_cast<int8_t>(fused_activation_function), 0);
4195   }
4196   explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4197   {
4198     start_ = fbb_.StartTable();
4199   }
4200   L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &);
4201   flatbuffers::Offset<L2NormOptions> Finish()
4202   {
4203     const auto end = fbb_.EndTable(start_);
4204     auto o = flatbuffers::Offset<L2NormOptions>(end);
4205     return o;
4206   }
4207 };
4208
4209 inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
4210   flatbuffers::FlatBufferBuilder &_fbb,
4211   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
4212 {
4213   L2NormOptionsBuilder builder_(_fbb);
4214   builder_.add_fused_activation_function(fused_activation_function);
4215   return builder_.Finish();
4216 }
4217
4218 struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4219 {
4220   typedef LocalResponseNormalizationOptionsBuilder Builder;
4221   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4222   {
4223     VT_RADIUS = 4,
4224     VT_BIAS = 6,
4225     VT_ALPHA = 8,
4226     VT_BETA = 10
4227   };
4228   int32_t radius() const { return GetField<int32_t>(VT_RADIUS, 0); }
4229   float bias() const { return GetField<float>(VT_BIAS, 0.0f); }
4230   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
4231   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
4232   bool Verify(flatbuffers::Verifier &verifier) const
4233   {
4234     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RADIUS) &&
4235            VerifyField<float>(verifier, VT_BIAS) && VerifyField<float>(verifier, VT_ALPHA) &&
4236            VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
4237   }
4238 };
4239
4240 struct LocalResponseNormalizationOptionsBuilder
4241 {
4242   typedef LocalResponseNormalizationOptions Table;
4243   flatbuffers::FlatBufferBuilder &fbb_;
4244   flatbuffers::uoffset_t start_;
4245   void add_radius(int32_t radius)
4246   {
4247     fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
4248   }
4249   void add_bias(float bias)
4250   {
4251     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
4252   }
4253   void add_alpha(float alpha)
4254   {
4255     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
4256   }
4257   void add_beta(float beta)
4258   {
4259     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
4260   }
4261   explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4262     : fbb_(_fbb)
4263   {
4264     start_ = fbb_.StartTable();
4265   }
4266   LocalResponseNormalizationOptionsBuilder &
4267   operator=(const LocalResponseNormalizationOptionsBuilder &);
4268   flatbuffers::Offset<LocalResponseNormalizationOptions> Finish()
4269   {
4270     const auto end = fbb_.EndTable(start_);
4271     auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
4272     return o;
4273   }
4274 };
4275
4276 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
4277 CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t radius = 0,
4278                                         float bias = 0.0f, float alpha = 0.0f, float beta = 0.0f)
4279 {
4280   LocalResponseNormalizationOptionsBuilder builder_(_fbb);
4281   builder_.add_beta(beta);
4282   builder_.add_alpha(alpha);
4283   builder_.add_bias(bias);
4284   builder_.add_radius(radius);
4285   return builder_.Finish();
4286 }
4287
4288 struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4289 {
4290   typedef LSTMOptionsBuilder Builder;
4291   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4292   {
4293     VT_FUSED_ACTIVATION_FUNCTION = 4,
4294     VT_CELL_CLIP = 6,
4295     VT_PROJ_CLIP = 8,
4296     VT_KERNEL_TYPE = 10,
4297     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
4298   };
4299   circle::ActivationFunctionType fused_activation_function() const
4300   {
4301     return static_cast<circle::ActivationFunctionType>(
4302       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4303   }
4304   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4305   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4306   circle::LSTMKernelType kernel_type() const
4307   {
4308     return static_cast<circle::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
4309   }
4310   bool asymmetric_quantize_inputs() const
4311   {
4312     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4313   }
4314   bool Verify(flatbuffers::Verifier &verifier) const
4315   {
4316     return VerifyTableStart(verifier) &&
4317            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4318            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4319            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4320            VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
4321            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4322   }
4323 };
4324
4325 struct LSTMOptionsBuilder
4326 {
4327   typedef LSTMOptions Table;
4328   flatbuffers::FlatBufferBuilder &fbb_;
4329   flatbuffers::uoffset_t start_;
4330   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4331   {
4332     fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4333                             static_cast<int8_t>(fused_activation_function), 0);
4334   }
4335   void add_cell_clip(float cell_clip)
4336   {
4337     fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4338   }
4339   void add_proj_clip(float proj_clip)
4340   {
4341     fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4342   }
4343   void add_kernel_type(circle::LSTMKernelType kernel_type)
4344   {
4345     fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
4346   }
4347   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4348   {
4349     fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4350                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4351   }
4352   explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4353   {
4354     start_ = fbb_.StartTable();
4355   }
4356   LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &);
4357   flatbuffers::Offset<LSTMOptions> Finish()
4358   {
4359     const auto end = fbb_.EndTable(start_);
4360     auto o = flatbuffers::Offset<LSTMOptions>(end);
4361     return o;
4362   }
4363 };
4364
4365 inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
4366   flatbuffers::FlatBufferBuilder &_fbb,
4367   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
4368   float cell_clip = 0.0f, float proj_clip = 0.0f,
4369   circle::LSTMKernelType kernel_type = circle::LSTMKernelType_FULL,
4370   bool asymmetric_quantize_inputs = false)
4371 {
4372   LSTMOptionsBuilder builder_(_fbb);
4373   builder_.add_proj_clip(proj_clip);
4374   builder_.add_cell_clip(cell_clip);
4375   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4376   builder_.add_kernel_type(kernel_type);
4377   builder_.add_fused_activation_function(fused_activation_function);
4378   return builder_.Finish();
4379 }
4380
4381 struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4382 {
4383   typedef UnidirectionalSequenceLSTMOptionsBuilder Builder;
4384   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4385   {
4386     VT_FUSED_ACTIVATION_FUNCTION = 4,
4387     VT_CELL_CLIP = 6,
4388     VT_PROJ_CLIP = 8,
4389     VT_TIME_MAJOR = 10,
4390     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
4391   };
4392   circle::ActivationFunctionType fused_activation_function() const
4393   {
4394     return static_cast<circle::ActivationFunctionType>(
4395       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4396   }
4397   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4398   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4399   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
4400   bool asymmetric_quantize_inputs() const
4401   {
4402     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4403   }
4404   bool Verify(flatbuffers::Verifier &verifier) const
4405   {
4406     return VerifyTableStart(verifier) &&
4407            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4408            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4409            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4410            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4411            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4412   }
4413 };
4414
4415 struct UnidirectionalSequenceLSTMOptionsBuilder
4416 {
4417   typedef UnidirectionalSequenceLSTMOptions Table;
4418   flatbuffers::FlatBufferBuilder &fbb_;
4419   flatbuffers::uoffset_t start_;
4420   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4421   {
4422     fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4423                             static_cast<int8_t>(fused_activation_function), 0);
4424   }
4425   void add_cell_clip(float cell_clip)
4426   {
4427     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4428   }
4429   void add_proj_clip(float proj_clip)
4430   {
4431     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4432   }
4433   void add_time_major(bool time_major)
4434   {
4435     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
4436                              static_cast<uint8_t>(time_major), 0);
4437   }
4438   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4439   {
4440     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4441                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4442   }
4443   explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4444     : fbb_(_fbb)
4445   {
4446     start_ = fbb_.StartTable();
4447   }
4448   UnidirectionalSequenceLSTMOptionsBuilder &
4449   operator=(const UnidirectionalSequenceLSTMOptionsBuilder &);
4450   flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish()
4451   {
4452     const auto end = fbb_.EndTable(start_);
4453     auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
4454     return o;
4455   }
4456 };
4457
4458 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
4459 CreateUnidirectionalSequenceLSTMOptions(
4460   flatbuffers::FlatBufferBuilder &_fbb,
4461   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
4462   float cell_clip = 0.0f, float proj_clip = 0.0f, bool time_major = false,
4463   bool asymmetric_quantize_inputs = false)
4464 {
4465   UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
4466   builder_.add_proj_clip(proj_clip);
4467   builder_.add_cell_clip(cell_clip);
4468   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4469   builder_.add_time_major(time_major);
4470   builder_.add_fused_activation_function(fused_activation_function);
4471   return builder_.Finish();
4472 }
4473
4474 struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4475 {
4476   typedef BidirectionalSequenceLSTMOptionsBuilder Builder;
4477   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4478   {
4479     VT_FUSED_ACTIVATION_FUNCTION = 4,
4480     VT_CELL_CLIP = 6,
4481     VT_PROJ_CLIP = 8,
4482     VT_MERGE_OUTPUTS = 10,
4483     VT_TIME_MAJOR = 12,
4484     VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
4485   };
4486   circle::ActivationFunctionType fused_activation_function() const
4487   {
4488     return static_cast<circle::ActivationFunctionType>(
4489       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
4490   }
4491   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
4492   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
4493   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
4494   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0; }
4495   bool asymmetric_quantize_inputs() const
4496   {
4497     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
4498   }
4499   bool Verify(flatbuffers::Verifier &verifier) const
4500   {
4501     return VerifyTableStart(verifier) &&
4502            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
4503            VerifyField<float>(verifier, VT_CELL_CLIP) &&
4504            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
4505            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
4506            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
4507            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
4508   }
4509 };
4510
4511 struct BidirectionalSequenceLSTMOptionsBuilder
4512 {
4513   typedef BidirectionalSequenceLSTMOptions Table;
4514   flatbuffers::FlatBufferBuilder &fbb_;
4515   flatbuffers::uoffset_t start_;
4516   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
4517   {
4518     fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
4519                             static_cast<int8_t>(fused_activation_function), 0);
4520   }
4521   void add_cell_clip(float cell_clip)
4522   {
4523     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
4524   }
4525   void add_proj_clip(float proj_clip)
4526   {
4527     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
4528   }
4529   void add_merge_outputs(bool merge_outputs)
4530   {
4531     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS,
4532                              static_cast<uint8_t>(merge_outputs), 0);
4533   }
4534   void add_time_major(bool time_major)
4535   {
4536     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
4537                              static_cast<uint8_t>(time_major), 1);
4538   }
4539   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
4540   {
4541     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
4542                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
4543   }
4544   explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4545     : fbb_(_fbb)
4546   {
4547     start_ = fbb_.StartTable();
4548   }
4549   BidirectionalSequenceLSTMOptionsBuilder &
4550   operator=(const BidirectionalSequenceLSTMOptionsBuilder &);
4551   flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish()
4552   {
4553     const auto end = fbb_.EndTable(start_);
4554     auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
4555     return o;
4556   }
4557 };
4558
4559 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
4560   flatbuffers::FlatBufferBuilder &_fbb,
4561   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
4562   float cell_clip = 0.0f, float proj_clip = 0.0f, bool merge_outputs = false,
4563   bool time_major = true, bool asymmetric_quantize_inputs = false)
4564 {
4565   BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
4566   builder_.add_proj_clip(proj_clip);
4567   builder_.add_cell_clip(cell_clip);
4568   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
4569   builder_.add_time_major(time_major);
4570   builder_.add_merge_outputs(merge_outputs);
4571   builder_.add_fused_activation_function(fused_activation_function);
4572   return builder_.Finish();
4573 }
4574
4575 struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4576 {
4577   typedef ResizeBilinearOptionsBuilder Builder;
4578   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4579   {
4580     VT_ALIGN_CORNERS = 8,
4581     VT_HALF_PIXEL_CENTERS = 10
4582   };
4583   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
4584   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
4585   bool Verify(flatbuffers::Verifier &verifier) const
4586   {
4587     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
4588            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
4589   }
4590 };
4591
4592 struct ResizeBilinearOptionsBuilder
4593 {
4594   typedef ResizeBilinearOptions Table;
4595   flatbuffers::FlatBufferBuilder &fbb_;
4596   flatbuffers::uoffset_t start_;
4597   void add_align_corners(bool align_corners)
4598   {
4599     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS,
4600                              static_cast<uint8_t>(align_corners), 0);
4601   }
4602   void add_half_pixel_centers(bool half_pixel_centers)
4603   {
4604     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS,
4605                              static_cast<uint8_t>(half_pixel_centers), 0);
4606   }
4607   explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4608   {
4609     start_ = fbb_.StartTable();
4610   }
4611   ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &);
4612   flatbuffers::Offset<ResizeBilinearOptions> Finish()
4613   {
4614     const auto end = fbb_.EndTable(start_);
4615     auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
4616     return o;
4617   }
4618 };
4619
4620 inline flatbuffers::Offset<ResizeBilinearOptions>
4621 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
4622                             bool half_pixel_centers = false)
4623 {
4624   ResizeBilinearOptionsBuilder builder_(_fbb);
4625   builder_.add_half_pixel_centers(half_pixel_centers);
4626   builder_.add_align_corners(align_corners);
4627   return builder_.Finish();
4628 }
4629
4630 struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4631 {
4632   typedef ResizeNearestNeighborOptionsBuilder Builder;
4633   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4634   {
4635     VT_ALIGN_CORNERS = 4
4636   };
4637   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
4638   bool Verify(flatbuffers::Verifier &verifier) const
4639   {
4640     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
4641            verifier.EndTable();
4642   }
4643 };
4644
4645 struct ResizeNearestNeighborOptionsBuilder
4646 {
4647   typedef ResizeNearestNeighborOptions Table;
4648   flatbuffers::FlatBufferBuilder &fbb_;
4649   flatbuffers::uoffset_t start_;
4650   void add_align_corners(bool align_corners)
4651   {
4652     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS,
4653                              static_cast<uint8_t>(align_corners), 0);
4654   }
4655   explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4656   {
4657     start_ = fbb_.StartTable();
4658   }
4659   ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &);
4660   flatbuffers::Offset<ResizeNearestNeighborOptions> Finish()
4661   {
4662     const auto end = fbb_.EndTable(start_);
4663     auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
4664     return o;
4665   }
4666 };
4667
4668 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
4669 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false)
4670 {
4671   ResizeNearestNeighborOptionsBuilder builder_(_fbb);
4672   builder_.add_align_corners(align_corners);
4673   return builder_.Finish();
4674 }
4675
4676 struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4677 {
4678   typedef CallOptionsBuilder Builder;
4679   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4680   {
4681     VT_SUBGRAPH = 4
4682   };
4683   uint32_t subgraph() const { return GetField<uint32_t>(VT_SUBGRAPH, 0); }
4684   bool Verify(flatbuffers::Verifier &verifier) const
4685   {
4686     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
4687            verifier.EndTable();
4688   }
4689 };
4690
4691 struct CallOptionsBuilder
4692 {
4693   typedef CallOptions Table;
4694   flatbuffers::FlatBufferBuilder &fbb_;
4695   flatbuffers::uoffset_t start_;
4696   void add_subgraph(uint32_t subgraph)
4697   {
4698     fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
4699   }
4700   explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4701   {
4702     start_ = fbb_.StartTable();
4703   }
4704   CallOptionsBuilder &operator=(const CallOptionsBuilder &);
4705   flatbuffers::Offset<CallOptions> Finish()
4706   {
4707     const auto end = fbb_.EndTable(start_);
4708     auto o = flatbuffers::Offset<CallOptions>(end);
4709     return o;
4710   }
4711 };
4712
4713 inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb,
4714                                                           uint32_t subgraph = 0)
4715 {
4716   CallOptionsBuilder builder_(_fbb);
4717   builder_.add_subgraph(subgraph);
4718   return builder_.Finish();
4719 }
4720
4721 struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4722 {
4723   typedef PadOptionsBuilder Builder;
4724   bool Verify(flatbuffers::Verifier &verifier) const
4725   {
4726     return VerifyTableStart(verifier) && verifier.EndTable();
4727   }
4728 };
4729
4730 struct PadOptionsBuilder
4731 {
4732   typedef PadOptions Table;
4733   flatbuffers::FlatBufferBuilder &fbb_;
4734   flatbuffers::uoffset_t start_;
4735   explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4736   {
4737     start_ = fbb_.StartTable();
4738   }
4739   PadOptionsBuilder &operator=(const PadOptionsBuilder &);
4740   flatbuffers::Offset<PadOptions> Finish()
4741   {
4742     const auto end = fbb_.EndTable(start_);
4743     auto o = flatbuffers::Offset<PadOptions>(end);
4744     return o;
4745   }
4746 };
4747
4748 inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb)
4749 {
4750   PadOptionsBuilder builder_(_fbb);
4751   return builder_.Finish();
4752 }
4753
4754 struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4755 {
4756   typedef PadV2OptionsBuilder Builder;
4757   bool Verify(flatbuffers::Verifier &verifier) const
4758   {
4759     return VerifyTableStart(verifier) && verifier.EndTable();
4760   }
4761 };
4762
4763 struct PadV2OptionsBuilder
4764 {
4765   typedef PadV2Options Table;
4766   flatbuffers::FlatBufferBuilder &fbb_;
4767   flatbuffers::uoffset_t start_;
4768   explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4769   {
4770     start_ = fbb_.StartTable();
4771   }
4772   PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &);
4773   flatbuffers::Offset<PadV2Options> Finish()
4774   {
4775     const auto end = fbb_.EndTable(start_);
4776     auto o = flatbuffers::Offset<PadV2Options>(end);
4777     return o;
4778   }
4779 };
4780
4781 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb)
4782 {
4783   PadV2OptionsBuilder builder_(_fbb);
4784   return builder_.Finish();
4785 }
4786
4787 struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4788 {
4789   typedef ReshapeOptionsBuilder Builder;
4790   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4791   {
4792     VT_NEW_SHAPE = 4
4793   };
4794   const flatbuffers::Vector<int32_t> *new_shape() const
4795   {
4796     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
4797   }
4798   bool Verify(flatbuffers::Verifier &verifier) const
4799   {
4800     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) &&
4801            verifier.VerifyVector(new_shape()) && verifier.EndTable();
4802   }
4803 };
4804
4805 struct ReshapeOptionsBuilder
4806 {
4807   typedef ReshapeOptions Table;
4808   flatbuffers::FlatBufferBuilder &fbb_;
4809   flatbuffers::uoffset_t start_;
4810   void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape)
4811   {
4812     fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
4813   }
4814   explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4815   {
4816     start_ = fbb_.StartTable();
4817   }
4818   ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &);
4819   flatbuffers::Offset<ReshapeOptions> Finish()
4820   {
4821     const auto end = fbb_.EndTable(start_);
4822     auto o = flatbuffers::Offset<ReshapeOptions>(end);
4823     return o;
4824   }
4825 };
4826
4827 inline flatbuffers::Offset<ReshapeOptions>
4828 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
4829                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0)
4830 {
4831   ReshapeOptionsBuilder builder_(_fbb);
4832   builder_.add_new_shape(new_shape);
4833   return builder_.Finish();
4834 }
4835
4836 inline flatbuffers::Offset<ReshapeOptions>
4837 CreateReshapeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
4838                            const std::vector<int32_t> *new_shape = nullptr)
4839 {
4840   auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
4841   return circle::CreateReshapeOptions(_fbb, new_shape__);
4842 }
4843
4844 struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4845 {
4846   typedef SpaceToBatchNDOptionsBuilder Builder;
4847   bool Verify(flatbuffers::Verifier &verifier) const
4848   {
4849     return VerifyTableStart(verifier) && verifier.EndTable();
4850   }
4851 };
4852
4853 struct SpaceToBatchNDOptionsBuilder
4854 {
4855   typedef SpaceToBatchNDOptions Table;
4856   flatbuffers::FlatBufferBuilder &fbb_;
4857   flatbuffers::uoffset_t start_;
4858   explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4859   {
4860     start_ = fbb_.StartTable();
4861   }
4862   SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &);
4863   flatbuffers::Offset<SpaceToBatchNDOptions> Finish()
4864   {
4865     const auto end = fbb_.EndTable(start_);
4866     auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
4867     return o;
4868   }
4869 };
4870
4871 inline flatbuffers::Offset<SpaceToBatchNDOptions>
4872 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
4873 {
4874   SpaceToBatchNDOptionsBuilder builder_(_fbb);
4875   return builder_.Finish();
4876 }
4877
4878 struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4879 {
4880   typedef BatchToSpaceNDOptionsBuilder Builder;
4881   bool Verify(flatbuffers::Verifier &verifier) const
4882   {
4883     return VerifyTableStart(verifier) && verifier.EndTable();
4884   }
4885 };
4886
4887 struct BatchToSpaceNDOptionsBuilder
4888 {
4889   typedef BatchToSpaceNDOptions Table;
4890   flatbuffers::FlatBufferBuilder &fbb_;
4891   flatbuffers::uoffset_t start_;
4892   explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4893   {
4894     start_ = fbb_.StartTable();
4895   }
4896   BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &);
4897   flatbuffers::Offset<BatchToSpaceNDOptions> Finish()
4898   {
4899     const auto end = fbb_.EndTable(start_);
4900     auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
4901     return o;
4902   }
4903 };
4904
4905 inline flatbuffers::Offset<BatchToSpaceNDOptions>
4906 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
4907 {
4908   BatchToSpaceNDOptionsBuilder builder_(_fbb);
4909   return builder_.Finish();
4910 }
4911
4912 struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4913 {
4914   typedef SkipGramOptionsBuilder Builder;
4915   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4916   {
4917     VT_NGRAM_SIZE = 4,
4918     VT_MAX_SKIP_SIZE = 6,
4919     VT_INCLUDE_ALL_NGRAMS = 8
4920   };
4921   int32_t ngram_size() const { return GetField<int32_t>(VT_NGRAM_SIZE, 0); }
4922   int32_t max_skip_size() const { return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0); }
4923   bool include_all_ngrams() const { return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0; }
4924   bool Verify(flatbuffers::Verifier &verifier) const
4925   {
4926     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
4927            VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
4928            VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) && verifier.EndTable();
4929   }
4930 };
4931
4932 struct SkipGramOptionsBuilder
4933 {
4934   typedef SkipGramOptions Table;
4935   flatbuffers::FlatBufferBuilder &fbb_;
4936   flatbuffers::uoffset_t start_;
4937   void add_ngram_size(int32_t ngram_size)
4938   {
4939     fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
4940   }
4941   void add_max_skip_size(int32_t max_skip_size)
4942   {
4943     fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
4944   }
4945   void add_include_all_ngrams(bool include_all_ngrams)
4946   {
4947     fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS,
4948                              static_cast<uint8_t>(include_all_ngrams), 0);
4949   }
4950   explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4951   {
4952     start_ = fbb_.StartTable();
4953   }
4954   SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &);
4955   flatbuffers::Offset<SkipGramOptions> Finish()
4956   {
4957     const auto end = fbb_.EndTable(start_);
4958     auto o = flatbuffers::Offset<SkipGramOptions>(end);
4959     return o;
4960   }
4961 };
4962
4963 inline flatbuffers::Offset<SkipGramOptions>
4964 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0,
4965                       int32_t max_skip_size = 0, bool include_all_ngrams = false)
4966 {
4967   SkipGramOptionsBuilder builder_(_fbb);
4968   builder_.add_max_skip_size(max_skip_size);
4969   builder_.add_ngram_size(ngram_size);
4970   builder_.add_include_all_ngrams(include_all_ngrams);
4971   return builder_.Finish();
4972 }
4973
4974 struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4975 {
4976   typedef SpaceToDepthOptionsBuilder Builder;
4977   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4978   {
4979     VT_BLOCK_SIZE = 4
4980   };
4981   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
4982   bool Verify(flatbuffers::Verifier &verifier) const
4983   {
4984     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
4985            verifier.EndTable();
4986   }
4987 };
4988
4989 struct SpaceToDepthOptionsBuilder
4990 {
4991   typedef SpaceToDepthOptions Table;
4992   flatbuffers::FlatBufferBuilder &fbb_;
4993   flatbuffers::uoffset_t start_;
4994   void add_block_size(int32_t block_size)
4995   {
4996     fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
4997   }
4998   explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4999   {
5000     start_ = fbb_.StartTable();
5001   }
5002   SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &);
5003   flatbuffers::Offset<SpaceToDepthOptions> Finish()
5004   {
5005     const auto end = fbb_.EndTable(start_);
5006     auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
5007     return o;
5008   }
5009 };
5010
5011 inline flatbuffers::Offset<SpaceToDepthOptions>
5012 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
5013 {
5014   SpaceToDepthOptionsBuilder builder_(_fbb);
5015   builder_.add_block_size(block_size);
5016   return builder_.Finish();
5017 }
5018
5019 struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5020 {
5021   typedef DepthToSpaceOptionsBuilder Builder;
5022   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5023   {
5024     VT_BLOCK_SIZE = 4
5025   };
5026   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
5027   bool Verify(flatbuffers::Verifier &verifier) const
5028   {
5029     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
5030            verifier.EndTable();
5031   }
5032 };
5033
5034 struct DepthToSpaceOptionsBuilder
5035 {
5036   typedef DepthToSpaceOptions Table;
5037   flatbuffers::FlatBufferBuilder &fbb_;
5038   flatbuffers::uoffset_t start_;
5039   void add_block_size(int32_t block_size)
5040   {
5041     fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
5042   }
5043   explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5044   {
5045     start_ = fbb_.StartTable();
5046   }
5047   DepthToSpaceOptionsBuilder &operator=(const DepthToSpaceOptionsBuilder &);
5048   flatbuffers::Offset<DepthToSpaceOptions> Finish()
5049   {
5050     const auto end = fbb_.EndTable(start_);
5051     auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
5052     return o;
5053   }
5054 };
5055
5056 inline flatbuffers::Offset<DepthToSpaceOptions>
5057 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
5058 {
5059   DepthToSpaceOptionsBuilder builder_(_fbb);
5060   builder_.add_block_size(block_size);
5061   return builder_.Finish();
5062 }
5063
5064 struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5065 {
5066   typedef SubOptionsBuilder Builder;
5067   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5068   {
5069     VT_FUSED_ACTIVATION_FUNCTION = 4
5070   };
5071   circle::ActivationFunctionType fused_activation_function() const
5072   {
5073     return static_cast<circle::ActivationFunctionType>(
5074       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5075   }
5076   bool Verify(flatbuffers::Verifier &verifier) const
5077   {
5078     return VerifyTableStart(verifier) &&
5079            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
5080   }
5081 };
5082
5083 struct SubOptionsBuilder
5084 {
5085   typedef SubOptions Table;
5086   flatbuffers::FlatBufferBuilder &fbb_;
5087   flatbuffers::uoffset_t start_;
5088   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5089   {
5090     fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION,
5091                             static_cast<int8_t>(fused_activation_function), 0);
5092   }
5093   explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5094   {
5095     start_ = fbb_.StartTable();
5096   }
5097   SubOptionsBuilder &operator=(const SubOptionsBuilder &);
5098   flatbuffers::Offset<SubOptions> Finish()
5099   {
5100     const auto end = fbb_.EndTable(start_);
5101     auto o = flatbuffers::Offset<SubOptions>(end);
5102     return o;
5103   }
5104 };
5105
5106 inline flatbuffers::Offset<SubOptions> CreateSubOptions(
5107   flatbuffers::FlatBufferBuilder &_fbb,
5108   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
5109 {
5110   SubOptionsBuilder builder_(_fbb);
5111   builder_.add_fused_activation_function(fused_activation_function);
5112   return builder_.Finish();
5113 }
5114
5115 struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5116 {
5117   typedef DivOptionsBuilder Builder;
5118   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5119   {
5120     VT_FUSED_ACTIVATION_FUNCTION = 4
5121   };
5122   circle::ActivationFunctionType fused_activation_function() const
5123   {
5124     return static_cast<circle::ActivationFunctionType>(
5125       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5126   }
5127   bool Verify(flatbuffers::Verifier &verifier) const
5128   {
5129     return VerifyTableStart(verifier) &&
5130            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
5131   }
5132 };
5133
5134 struct DivOptionsBuilder
5135 {
5136   typedef DivOptions Table;
5137   flatbuffers::FlatBufferBuilder &fbb_;
5138   flatbuffers::uoffset_t start_;
5139   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5140   {
5141     fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION,
5142                             static_cast<int8_t>(fused_activation_function), 0);
5143   }
5144   explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5145   {
5146     start_ = fbb_.StartTable();
5147   }
5148   DivOptionsBuilder &operator=(const DivOptionsBuilder &);
5149   flatbuffers::Offset<DivOptions> Finish()
5150   {
5151     const auto end = fbb_.EndTable(start_);
5152     auto o = flatbuffers::Offset<DivOptions>(end);
5153     return o;
5154   }
5155 };
5156
5157 inline flatbuffers::Offset<DivOptions> CreateDivOptions(
5158   flatbuffers::FlatBufferBuilder &_fbb,
5159   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
5160 {
5161   DivOptionsBuilder builder_(_fbb);
5162   builder_.add_fused_activation_function(fused_activation_function);
5163   return builder_.Finish();
5164 }
5165
5166 struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5167 {
5168   typedef TopKV2OptionsBuilder Builder;
5169   bool Verify(flatbuffers::Verifier &verifier) const
5170   {
5171     return VerifyTableStart(verifier) && verifier.EndTable();
5172   }
5173 };
5174
5175 struct TopKV2OptionsBuilder
5176 {
5177   typedef TopKV2Options Table;
5178   flatbuffers::FlatBufferBuilder &fbb_;
5179   flatbuffers::uoffset_t start_;
5180   explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5181   {
5182     start_ = fbb_.StartTable();
5183   }
5184   TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &);
5185   flatbuffers::Offset<TopKV2Options> Finish()
5186   {
5187     const auto end = fbb_.EndTable(start_);
5188     auto o = flatbuffers::Offset<TopKV2Options>(end);
5189     return o;
5190   }
5191 };
5192
5193 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb)
5194 {
5195   TopKV2OptionsBuilder builder_(_fbb);
5196   return builder_.Finish();
5197 }
5198
5199 struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5200 {
5201   typedef EmbeddingLookupSparseOptionsBuilder Builder;
5202   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5203   {
5204     VT_COMBINER = 4
5205   };
5206   circle::CombinerType combiner() const
5207   {
5208     return static_cast<circle::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
5209   }
5210   bool Verify(flatbuffers::Verifier &verifier) const
5211   {
5212     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_COMBINER) &&
5213            verifier.EndTable();
5214   }
5215 };
5216
5217 struct EmbeddingLookupSparseOptionsBuilder
5218 {
5219   typedef EmbeddingLookupSparseOptions Table;
5220   flatbuffers::FlatBufferBuilder &fbb_;
5221   flatbuffers::uoffset_t start_;
5222   void add_combiner(circle::CombinerType combiner)
5223   {
5224     fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER,
5225                             static_cast<int8_t>(combiner), 0);
5226   }
5227   explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5228   {
5229     start_ = fbb_.StartTable();
5230   }
5231   EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &);
5232   flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish()
5233   {
5234     const auto end = fbb_.EndTable(start_);
5235     auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
5236     return o;
5237   }
5238 };
5239
5240 inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
5241 CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
5242                                    circle::CombinerType combiner = circle::CombinerType_SUM)
5243 {
5244   EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
5245   builder_.add_combiner(combiner);
5246   return builder_.Finish();
5247 }
5248
5249 struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5250 {
5251   typedef GatherOptionsBuilder Builder;
5252   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5253   {
5254     VT_AXIS = 4
5255   };
5256   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
5257   bool Verify(flatbuffers::Verifier &verifier) const
5258   {
5259     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
5260            verifier.EndTable();
5261   }
5262 };
5263
5264 struct GatherOptionsBuilder
5265 {
5266   typedef GatherOptions Table;
5267   flatbuffers::FlatBufferBuilder &fbb_;
5268   flatbuffers::uoffset_t start_;
5269   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0); }
5270   explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5271   {
5272     start_ = fbb_.StartTable();
5273   }
5274   GatherOptionsBuilder &operator=(const GatherOptionsBuilder &);
5275   flatbuffers::Offset<GatherOptions> Finish()
5276   {
5277     const auto end = fbb_.EndTable(start_);
5278     auto o = flatbuffers::Offset<GatherOptions>(end);
5279     return o;
5280   }
5281 };
5282
5283 inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb,
5284                                                               int32_t axis = 0)
5285 {
5286   GatherOptionsBuilder builder_(_fbb);
5287   builder_.add_axis(axis);
5288   return builder_.Finish();
5289 }
5290
5291 struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5292 {
5293   typedef TransposeOptionsBuilder Builder;
5294   bool Verify(flatbuffers::Verifier &verifier) const
5295   {
5296     return VerifyTableStart(verifier) && verifier.EndTable();
5297   }
5298 };
5299
5300 struct TransposeOptionsBuilder
5301 {
5302   typedef TransposeOptions Table;
5303   flatbuffers::FlatBufferBuilder &fbb_;
5304   flatbuffers::uoffset_t start_;
5305   explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5306   {
5307     start_ = fbb_.StartTable();
5308   }
5309   TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &);
5310   flatbuffers::Offset<TransposeOptions> Finish()
5311   {
5312     const auto end = fbb_.EndTable(start_);
5313     auto o = flatbuffers::Offset<TransposeOptions>(end);
5314     return o;
5315   }
5316 };
5317
5318 inline flatbuffers::Offset<TransposeOptions>
5319 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb)
5320 {
5321   TransposeOptionsBuilder builder_(_fbb);
5322   return builder_.Finish();
5323 }
5324
5325 struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5326 {
5327   typedef ExpOptionsBuilder Builder;
5328   bool Verify(flatbuffers::Verifier &verifier) const
5329   {
5330     return VerifyTableStart(verifier) && verifier.EndTable();
5331   }
5332 };
5333
5334 struct ExpOptionsBuilder
5335 {
5336   typedef ExpOptions Table;
5337   flatbuffers::FlatBufferBuilder &fbb_;
5338   flatbuffers::uoffset_t start_;
5339   explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5340   {
5341     start_ = fbb_.StartTable();
5342   }
5343   ExpOptionsBuilder &operator=(const ExpOptionsBuilder &);
5344   flatbuffers::Offset<ExpOptions> Finish()
5345   {
5346     const auto end = fbb_.EndTable(start_);
5347     auto o = flatbuffers::Offset<ExpOptions>(end);
5348     return o;
5349   }
5350 };
5351
5352 inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb)
5353 {
5354   ExpOptionsBuilder builder_(_fbb);
5355   return builder_.Finish();
5356 }
5357
5358 struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5359 {
5360   typedef CosOptionsBuilder Builder;
5361   bool Verify(flatbuffers::Verifier &verifier) const
5362   {
5363     return VerifyTableStart(verifier) && verifier.EndTable();
5364   }
5365 };
5366
5367 struct CosOptionsBuilder
5368 {
5369   typedef CosOptions Table;
5370   flatbuffers::FlatBufferBuilder &fbb_;
5371   flatbuffers::uoffset_t start_;
5372   explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5373   {
5374     start_ = fbb_.StartTable();
5375   }
5376   CosOptionsBuilder &operator=(const CosOptionsBuilder &);
5377   flatbuffers::Offset<CosOptions> Finish()
5378   {
5379     const auto end = fbb_.EndTable(start_);
5380     auto o = flatbuffers::Offset<CosOptions>(end);
5381     return o;
5382   }
5383 };
5384
5385 inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb)
5386 {
5387   CosOptionsBuilder builder_(_fbb);
5388   return builder_.Finish();
5389 }
5390
5391 struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5392 {
5393   typedef ReducerOptionsBuilder Builder;
5394   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5395   {
5396     VT_KEEP_DIMS = 4
5397   };
5398   bool keep_dims() const { return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; }
5399   bool Verify(flatbuffers::Verifier &verifier) const
5400   {
5401     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
5402            verifier.EndTable();
5403   }
5404 };
5405
5406 struct ReducerOptionsBuilder
5407 {
5408   typedef ReducerOptions Table;
5409   flatbuffers::FlatBufferBuilder &fbb_;
5410   flatbuffers::uoffset_t start_;
5411   void add_keep_dims(bool keep_dims)
5412   {
5413     fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
5414   }
5415   explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5416   {
5417     start_ = fbb_.StartTable();
5418   }
5419   ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &);
5420   flatbuffers::Offset<ReducerOptions> Finish()
5421   {
5422     const auto end = fbb_.EndTable(start_);
5423     auto o = flatbuffers::Offset<ReducerOptions>(end);
5424     return o;
5425   }
5426 };
5427
5428 inline flatbuffers::Offset<ReducerOptions>
5429 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false)
5430 {
5431   ReducerOptionsBuilder builder_(_fbb);
5432   builder_.add_keep_dims(keep_dims);
5433   return builder_.Finish();
5434 }
5435
5436 struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5437 {
5438   typedef SqueezeOptionsBuilder Builder;
5439   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5440   {
5441     VT_SQUEEZE_DIMS = 4
5442   };
5443   const flatbuffers::Vector<int32_t> *squeeze_dims() const
5444   {
5445     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
5446   }
5447   bool Verify(flatbuffers::Verifier &verifier) const
5448   {
5449     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
5450            verifier.VerifyVector(squeeze_dims()) && verifier.EndTable();
5451   }
5452 };
5453
5454 struct SqueezeOptionsBuilder
5455 {
5456   typedef SqueezeOptions Table;
5457   flatbuffers::FlatBufferBuilder &fbb_;
5458   flatbuffers::uoffset_t start_;
5459   void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims)
5460   {
5461     fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
5462   }
5463   explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5464   {
5465     start_ = fbb_.StartTable();
5466   }
5467   SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &);
5468   flatbuffers::Offset<SqueezeOptions> Finish()
5469   {
5470     const auto end = fbb_.EndTable(start_);
5471     auto o = flatbuffers::Offset<SqueezeOptions>(end);
5472     return o;
5473   }
5474 };
5475
5476 inline flatbuffers::Offset<SqueezeOptions>
5477 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb,
5478                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0)
5479 {
5480   SqueezeOptionsBuilder builder_(_fbb);
5481   builder_.add_squeeze_dims(squeeze_dims);
5482   return builder_.Finish();
5483 }
5484
5485 inline flatbuffers::Offset<SqueezeOptions>
5486 CreateSqueezeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
5487                            const std::vector<int32_t> *squeeze_dims = nullptr)
5488 {
5489   auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
5490   return circle::CreateSqueezeOptions(_fbb, squeeze_dims__);
5491 }
5492
5493 struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5494 {
5495   typedef SplitOptionsBuilder Builder;
5496   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5497   {
5498     VT_NUM_SPLITS = 4
5499   };
5500   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
5501   bool Verify(flatbuffers::Verifier &verifier) const
5502   {
5503     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
5504            verifier.EndTable();
5505   }
5506 };
5507
5508 struct SplitOptionsBuilder
5509 {
5510   typedef SplitOptions Table;
5511   flatbuffers::FlatBufferBuilder &fbb_;
5512   flatbuffers::uoffset_t start_;
5513   void add_num_splits(int32_t num_splits)
5514   {
5515     fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
5516   }
5517   explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5518   {
5519     start_ = fbb_.StartTable();
5520   }
5521   SplitOptionsBuilder &operator=(const SplitOptionsBuilder &);
5522   flatbuffers::Offset<SplitOptions> Finish()
5523   {
5524     const auto end = fbb_.EndTable(start_);
5525     auto o = flatbuffers::Offset<SplitOptions>(end);
5526     return o;
5527   }
5528 };
5529
5530 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb,
5531                                                             int32_t num_splits = 0)
5532 {
5533   SplitOptionsBuilder builder_(_fbb);
5534   builder_.add_num_splits(num_splits);
5535   return builder_.Finish();
5536 }
5537
5538 struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5539 {
5540   typedef SplitVOptionsBuilder Builder;
5541   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5542   {
5543     VT_NUM_SPLITS = 4
5544   };
5545   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
5546   bool Verify(flatbuffers::Verifier &verifier) const
5547   {
5548     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
5549            verifier.EndTable();
5550   }
5551 };
5552
5553 struct SplitVOptionsBuilder
5554 {
5555   typedef SplitVOptions Table;
5556   flatbuffers::FlatBufferBuilder &fbb_;
5557   flatbuffers::uoffset_t start_;
5558   void add_num_splits(int32_t num_splits)
5559   {
5560     fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
5561   }
5562   explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5563   {
5564     start_ = fbb_.StartTable();
5565   }
5566   SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &);
5567   flatbuffers::Offset<SplitVOptions> Finish()
5568   {
5569     const auto end = fbb_.EndTable(start_);
5570     auto o = flatbuffers::Offset<SplitVOptions>(end);
5571     return o;
5572   }
5573 };
5574
5575 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb,
5576                                                               int32_t num_splits = 0)
5577 {
5578   SplitVOptionsBuilder builder_(_fbb);
5579   builder_.add_num_splits(num_splits);
5580   return builder_.Finish();
5581 }
5582
5583 struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5584 {
5585   typedef StridedSliceOptionsBuilder Builder;
5586   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5587   {
5588     VT_BEGIN_MASK = 4,
5589     VT_END_MASK = 6,
5590     VT_ELLIPSIS_MASK = 8,
5591     VT_NEW_AXIS_MASK = 10,
5592     VT_SHRINK_AXIS_MASK = 12
5593   };
5594   int32_t begin_mask() const { return GetField<int32_t>(VT_BEGIN_MASK, 0); }
5595   int32_t end_mask() const { return GetField<int32_t>(VT_END_MASK, 0); }
5596   int32_t ellipsis_mask() const { return GetField<int32_t>(VT_ELLIPSIS_MASK, 0); }
5597   int32_t new_axis_mask() const { return GetField<int32_t>(VT_NEW_AXIS_MASK, 0); }
5598   int32_t shrink_axis_mask() const { return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0); }
5599   bool Verify(flatbuffers::Verifier &verifier) const
5600   {
5601     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
5602            VerifyField<int32_t>(verifier, VT_END_MASK) &&
5603            VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
5604            VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
5605            VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) && verifier.EndTable();
5606   }
5607 };
5608
5609 struct StridedSliceOptionsBuilder
5610 {
5611   typedef StridedSliceOptions Table;
5612   flatbuffers::FlatBufferBuilder &fbb_;
5613   flatbuffers::uoffset_t start_;
5614   void add_begin_mask(int32_t begin_mask)
5615   {
5616     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
5617   }
5618   void add_end_mask(int32_t end_mask)
5619   {
5620     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
5621   }
5622   void add_ellipsis_mask(int32_t ellipsis_mask)
5623   {
5624     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
5625   }
5626   void add_new_axis_mask(int32_t new_axis_mask)
5627   {
5628     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
5629   }
5630   void add_shrink_axis_mask(int32_t shrink_axis_mask)
5631   {
5632     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
5633   }
5634   explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5635   {
5636     start_ = fbb_.StartTable();
5637   }
5638   StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &);
5639   flatbuffers::Offset<StridedSliceOptions> Finish()
5640   {
5641     const auto end = fbb_.EndTable(start_);
5642     auto o = flatbuffers::Offset<StridedSliceOptions>(end);
5643     return o;
5644   }
5645 };
5646
5647 inline flatbuffers::Offset<StridedSliceOptions>
5648 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0,
5649                           int32_t end_mask = 0, int32_t ellipsis_mask = 0,
5650                           int32_t new_axis_mask = 0, int32_t shrink_axis_mask = 0)
5651 {
5652   StridedSliceOptionsBuilder builder_(_fbb);
5653   builder_.add_shrink_axis_mask(shrink_axis_mask);
5654   builder_.add_new_axis_mask(new_axis_mask);
5655   builder_.add_ellipsis_mask(ellipsis_mask);
5656   builder_.add_end_mask(end_mask);
5657   builder_.add_begin_mask(begin_mask);
5658   return builder_.Finish();
5659 }
5660
5661 struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5662 {
5663   typedef LogSoftmaxOptionsBuilder Builder;
5664   bool Verify(flatbuffers::Verifier &verifier) const
5665   {
5666     return VerifyTableStart(verifier) && verifier.EndTable();
5667   }
5668 };
5669
5670 struct LogSoftmaxOptionsBuilder
5671 {
5672   typedef LogSoftmaxOptions Table;
5673   flatbuffers::FlatBufferBuilder &fbb_;
5674   flatbuffers::uoffset_t start_;
5675   explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5676   {
5677     start_ = fbb_.StartTable();
5678   }
5679   LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &);
5680   flatbuffers::Offset<LogSoftmaxOptions> Finish()
5681   {
5682     const auto end = fbb_.EndTable(start_);
5683     auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
5684     return o;
5685   }
5686 };
5687
5688 inline flatbuffers::Offset<LogSoftmaxOptions>
5689 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
5690 {
5691   LogSoftmaxOptionsBuilder builder_(_fbb);
5692   return builder_.Finish();
5693 }
5694
5695 struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5696 {
5697   typedef CastOptionsBuilder Builder;
5698   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5699   {
5700     VT_IN_DATA_TYPE = 4,
5701     VT_OUT_DATA_TYPE = 6
5702   };
5703   circle::TensorType in_data_type() const
5704   {
5705     return static_cast<circle::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
5706   }
5707   circle::TensorType out_data_type() const
5708   {
5709     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
5710   }
5711   bool Verify(flatbuffers::Verifier &verifier) const
5712   {
5713     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
5714            VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) && verifier.EndTable();
5715   }
5716 };
5717
5718 struct CastOptionsBuilder
5719 {
5720   typedef CastOptions Table;
5721   flatbuffers::FlatBufferBuilder &fbb_;
5722   flatbuffers::uoffset_t start_;
5723   void add_in_data_type(circle::TensorType in_data_type)
5724   {
5725     fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
5726   }
5727   void add_out_data_type(circle::TensorType out_data_type)
5728   {
5729     fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
5730   }
5731   explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5732   {
5733     start_ = fbb_.StartTable();
5734   }
5735   CastOptionsBuilder &operator=(const CastOptionsBuilder &);
5736   flatbuffers::Offset<CastOptions> Finish()
5737   {
5738     const auto end = fbb_.EndTable(start_);
5739     auto o = flatbuffers::Offset<CastOptions>(end);
5740     return o;
5741   }
5742 };
5743
5744 inline flatbuffers::Offset<CastOptions>
5745 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb,
5746                   circle::TensorType in_data_type = circle::TensorType_FLOAT32,
5747                   circle::TensorType out_data_type = circle::TensorType_FLOAT32)
5748 {
5749   CastOptionsBuilder builder_(_fbb);
5750   builder_.add_out_data_type(out_data_type);
5751   builder_.add_in_data_type(in_data_type);
5752   return builder_.Finish();
5753 }
5754
5755 struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5756 {
5757   typedef DequantizeOptionsBuilder Builder;
5758   bool Verify(flatbuffers::Verifier &verifier) const
5759   {
5760     return VerifyTableStart(verifier) && verifier.EndTable();
5761   }
5762 };
5763
5764 struct DequantizeOptionsBuilder
5765 {
5766   typedef DequantizeOptions Table;
5767   flatbuffers::FlatBufferBuilder &fbb_;
5768   flatbuffers::uoffset_t start_;
5769   explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5770   {
5771     start_ = fbb_.StartTable();
5772   }
5773   DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &);
5774   flatbuffers::Offset<DequantizeOptions> Finish()
5775   {
5776     const auto end = fbb_.EndTable(start_);
5777     auto o = flatbuffers::Offset<DequantizeOptions>(end);
5778     return o;
5779   }
5780 };
5781
5782 inline flatbuffers::Offset<DequantizeOptions>
5783 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
5784 {
5785   DequantizeOptionsBuilder builder_(_fbb);
5786   return builder_.Finish();
5787 }
5788
5789 struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5790 {
5791   typedef MaximumMinimumOptionsBuilder Builder;
5792   bool Verify(flatbuffers::Verifier &verifier) const
5793   {
5794     return VerifyTableStart(verifier) && verifier.EndTable();
5795   }
5796 };
5797
5798 struct MaximumMinimumOptionsBuilder
5799 {
5800   typedef MaximumMinimumOptions Table;
5801   flatbuffers::FlatBufferBuilder &fbb_;
5802   flatbuffers::uoffset_t start_;
5803   explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5804   {
5805     start_ = fbb_.StartTable();
5806   }
5807   MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &);
5808   flatbuffers::Offset<MaximumMinimumOptions> Finish()
5809   {
5810     const auto end = fbb_.EndTable(start_);
5811     auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
5812     return o;
5813   }
5814 };
5815
5816 inline flatbuffers::Offset<MaximumMinimumOptions>
5817 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb)
5818 {
5819   MaximumMinimumOptionsBuilder builder_(_fbb);
5820   return builder_.Finish();
5821 }
5822
5823 struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5824 {
5825   typedef TileOptionsBuilder Builder;
5826   bool Verify(flatbuffers::Verifier &verifier) const
5827   {
5828     return VerifyTableStart(verifier) && verifier.EndTable();
5829   }
5830 };
5831
5832 struct TileOptionsBuilder
5833 {
5834   typedef TileOptions Table;
5835   flatbuffers::FlatBufferBuilder &fbb_;
5836   flatbuffers::uoffset_t start_;
5837   explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5838   {
5839     start_ = fbb_.StartTable();
5840   }
5841   TileOptionsBuilder &operator=(const TileOptionsBuilder &);
5842   flatbuffers::Offset<TileOptions> Finish()
5843   {
5844     const auto end = fbb_.EndTable(start_);
5845     auto o = flatbuffers::Offset<TileOptions>(end);
5846     return o;
5847   }
5848 };
5849
5850 inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb)
5851 {
5852   TileOptionsBuilder builder_(_fbb);
5853   return builder_.Finish();
5854 }
5855
5856 struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5857 {
5858   typedef ArgMaxOptionsBuilder Builder;
5859   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5860   {
5861     VT_OUTPUT_TYPE = 4
5862   };
5863   circle::TensorType output_type() const
5864   {
5865     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
5866   }
5867   bool Verify(flatbuffers::Verifier &verifier) const
5868   {
5869     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
5870            verifier.EndTable();
5871   }
5872 };
5873
5874 struct ArgMaxOptionsBuilder
5875 {
5876   typedef ArgMaxOptions Table;
5877   flatbuffers::FlatBufferBuilder &fbb_;
5878   flatbuffers::uoffset_t start_;
5879   void add_output_type(circle::TensorType output_type)
5880   {
5881     fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
5882   }
5883   explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5884   {
5885     start_ = fbb_.StartTable();
5886   }
5887   ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &);
5888   flatbuffers::Offset<ArgMaxOptions> Finish()
5889   {
5890     const auto end = fbb_.EndTable(start_);
5891     auto o = flatbuffers::Offset<ArgMaxOptions>(end);
5892     return o;
5893   }
5894 };
5895
5896 inline flatbuffers::Offset<ArgMaxOptions>
5897 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb,
5898                     circle::TensorType output_type = circle::TensorType_FLOAT32)
5899 {
5900   ArgMaxOptionsBuilder builder_(_fbb);
5901   builder_.add_output_type(output_type);
5902   return builder_.Finish();
5903 }
5904
5905 struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5906 {
5907   typedef ArgMinOptionsBuilder Builder;
5908   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5909   {
5910     VT_OUTPUT_TYPE = 4
5911   };
5912   circle::TensorType output_type() const
5913   {
5914     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
5915   }
5916   bool Verify(flatbuffers::Verifier &verifier) const
5917   {
5918     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
5919            verifier.EndTable();
5920   }
5921 };
5922
5923 struct ArgMinOptionsBuilder
5924 {
5925   typedef ArgMinOptions Table;
5926   flatbuffers::FlatBufferBuilder &fbb_;
5927   flatbuffers::uoffset_t start_;
5928   void add_output_type(circle::TensorType output_type)
5929   {
5930     fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
5931   }
5932   explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5933   {
5934     start_ = fbb_.StartTable();
5935   }
5936   ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &);
5937   flatbuffers::Offset<ArgMinOptions> Finish()
5938   {
5939     const auto end = fbb_.EndTable(start_);
5940     auto o = flatbuffers::Offset<ArgMinOptions>(end);
5941     return o;
5942   }
5943 };
5944
5945 inline flatbuffers::Offset<ArgMinOptions>
5946 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb,
5947                     circle::TensorType output_type = circle::TensorType_FLOAT32)
5948 {
5949   ArgMinOptionsBuilder builder_(_fbb);
5950   builder_.add_output_type(output_type);
5951   return builder_.Finish();
5952 }
5953
5954 struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5955 {
5956   typedef GreaterOptionsBuilder Builder;
5957   bool Verify(flatbuffers::Verifier &verifier) const
5958   {
5959     return VerifyTableStart(verifier) && verifier.EndTable();
5960   }
5961 };
5962
5963 struct GreaterOptionsBuilder
5964 {
5965   typedef GreaterOptions Table;
5966   flatbuffers::FlatBufferBuilder &fbb_;
5967   flatbuffers::uoffset_t start_;
5968   explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5969   {
5970     start_ = fbb_.StartTable();
5971   }
5972   GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &);
5973   flatbuffers::Offset<GreaterOptions> Finish()
5974   {
5975     const auto end = fbb_.EndTable(start_);
5976     auto o = flatbuffers::Offset<GreaterOptions>(end);
5977     return o;
5978   }
5979 };
5980
5981 inline flatbuffers::Offset<GreaterOptions>
5982 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb)
5983 {
5984   GreaterOptionsBuilder builder_(_fbb);
5985   return builder_.Finish();
5986 }
5987
5988 struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5989 {
5990   typedef GreaterEqualOptionsBuilder Builder;
5991   bool Verify(flatbuffers::Verifier &verifier) const
5992   {
5993     return VerifyTableStart(verifier) && verifier.EndTable();
5994   }
5995 };
5996
5997 struct GreaterEqualOptionsBuilder
5998 {
5999   typedef GreaterEqualOptions Table;
6000   flatbuffers::FlatBufferBuilder &fbb_;
6001   flatbuffers::uoffset_t start_;
6002   explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6003   {
6004     start_ = fbb_.StartTable();
6005   }
6006   GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &);
6007   flatbuffers::Offset<GreaterEqualOptions> Finish()
6008   {
6009     const auto end = fbb_.EndTable(start_);
6010     auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
6011     return o;
6012   }
6013 };
6014
6015 inline flatbuffers::Offset<GreaterEqualOptions>
6016 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6017 {
6018   GreaterEqualOptionsBuilder builder_(_fbb);
6019   return builder_.Finish();
6020 }
6021
6022 struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6023 {
6024   typedef LessOptionsBuilder Builder;
6025   bool Verify(flatbuffers::Verifier &verifier) const
6026   {
6027     return VerifyTableStart(verifier) && verifier.EndTable();
6028   }
6029 };
6030
6031 struct LessOptionsBuilder
6032 {
6033   typedef LessOptions Table;
6034   flatbuffers::FlatBufferBuilder &fbb_;
6035   flatbuffers::uoffset_t start_;
6036   explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6037   {
6038     start_ = fbb_.StartTable();
6039   }
6040   LessOptionsBuilder &operator=(const LessOptionsBuilder &);
6041   flatbuffers::Offset<LessOptions> Finish()
6042   {
6043     const auto end = fbb_.EndTable(start_);
6044     auto o = flatbuffers::Offset<LessOptions>(end);
6045     return o;
6046   }
6047 };
6048
6049 inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb)
6050 {
6051   LessOptionsBuilder builder_(_fbb);
6052   return builder_.Finish();
6053 }
6054
6055 struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6056 {
6057   typedef LessEqualOptionsBuilder Builder;
6058   bool Verify(flatbuffers::Verifier &verifier) const
6059   {
6060     return VerifyTableStart(verifier) && verifier.EndTable();
6061   }
6062 };
6063
6064 struct LessEqualOptionsBuilder
6065 {
6066   typedef LessEqualOptions Table;
6067   flatbuffers::FlatBufferBuilder &fbb_;
6068   flatbuffers::uoffset_t start_;
6069   explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6070   {
6071     start_ = fbb_.StartTable();
6072   }
6073   LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &);
6074   flatbuffers::Offset<LessEqualOptions> Finish()
6075   {
6076     const auto end = fbb_.EndTable(start_);
6077     auto o = flatbuffers::Offset<LessEqualOptions>(end);
6078     return o;
6079   }
6080 };
6081
6082 inline flatbuffers::Offset<LessEqualOptions>
6083 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6084 {
6085   LessEqualOptionsBuilder builder_(_fbb);
6086   return builder_.Finish();
6087 }
6088
6089 struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6090 {
6091   typedef NegOptionsBuilder Builder;
6092   bool Verify(flatbuffers::Verifier &verifier) const
6093   {
6094     return VerifyTableStart(verifier) && verifier.EndTable();
6095   }
6096 };
6097
6098 struct NegOptionsBuilder
6099 {
6100   typedef NegOptions Table;
6101   flatbuffers::FlatBufferBuilder &fbb_;
6102   flatbuffers::uoffset_t start_;
6103   explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6104   {
6105     start_ = fbb_.StartTable();
6106   }
6107   NegOptionsBuilder &operator=(const NegOptionsBuilder &);
6108   flatbuffers::Offset<NegOptions> Finish()
6109   {
6110     const auto end = fbb_.EndTable(start_);
6111     auto o = flatbuffers::Offset<NegOptions>(end);
6112     return o;
6113   }
6114 };
6115
6116 inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb)
6117 {
6118   NegOptionsBuilder builder_(_fbb);
6119   return builder_.Finish();
6120 }
6121
6122 struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6123 {
6124   typedef SelectOptionsBuilder Builder;
6125   bool Verify(flatbuffers::Verifier &verifier) const
6126   {
6127     return VerifyTableStart(verifier) && verifier.EndTable();
6128   }
6129 };
6130
6131 struct SelectOptionsBuilder
6132 {
6133   typedef SelectOptions Table;
6134   flatbuffers::FlatBufferBuilder &fbb_;
6135   flatbuffers::uoffset_t start_;
6136   explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6137   {
6138     start_ = fbb_.StartTable();
6139   }
6140   SelectOptionsBuilder &operator=(const SelectOptionsBuilder &);
6141   flatbuffers::Offset<SelectOptions> Finish()
6142   {
6143     const auto end = fbb_.EndTable(start_);
6144     auto o = flatbuffers::Offset<SelectOptions>(end);
6145     return o;
6146   }
6147 };
6148
6149 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb)
6150 {
6151   SelectOptionsBuilder builder_(_fbb);
6152   return builder_.Finish();
6153 }
6154
6155 struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6156 {
6157   typedef SliceOptionsBuilder Builder;
6158   bool Verify(flatbuffers::Verifier &verifier) const
6159   {
6160     return VerifyTableStart(verifier) && verifier.EndTable();
6161   }
6162 };
6163
6164 struct SliceOptionsBuilder
6165 {
6166   typedef SliceOptions Table;
6167   flatbuffers::FlatBufferBuilder &fbb_;
6168   flatbuffers::uoffset_t start_;
6169   explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6170   {
6171     start_ = fbb_.StartTable();
6172   }
6173   SliceOptionsBuilder &operator=(const SliceOptionsBuilder &);
6174   flatbuffers::Offset<SliceOptions> Finish()
6175   {
6176     const auto end = fbb_.EndTable(start_);
6177     auto o = flatbuffers::Offset<SliceOptions>(end);
6178     return o;
6179   }
6180 };
6181
6182 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
6183 {
6184   SliceOptionsBuilder builder_(_fbb);
6185   return builder_.Finish();
6186 }
6187
6188 struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6189 {
6190   typedef TransposeConvOptionsBuilder Builder;
6191   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6192   {
6193     VT_PADDING = 4,
6194     VT_STRIDE_W = 6,
6195     VT_STRIDE_H = 8
6196   };
6197   circle::Padding padding() const
6198   {
6199     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
6200   }
6201   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
6202   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
6203   bool Verify(flatbuffers::Verifier &verifier) const
6204   {
6205     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
6206            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
6207            VerifyField<int32_t>(verifier, VT_STRIDE_H) && verifier.EndTable();
6208   }
6209 };
6210
6211 struct TransposeConvOptionsBuilder
6212 {
6213   typedef TransposeConvOptions Table;
6214   flatbuffers::FlatBufferBuilder &fbb_;
6215   flatbuffers::uoffset_t start_;
6216   void add_padding(circle::Padding padding)
6217   {
6218     fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
6219   }
6220   void add_stride_w(int32_t stride_w)
6221   {
6222     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
6223   }
6224   void add_stride_h(int32_t stride_h)
6225   {
6226     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
6227   }
6228   explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6229   {
6230     start_ = fbb_.StartTable();
6231   }
6232   TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &);
6233   flatbuffers::Offset<TransposeConvOptions> Finish()
6234   {
6235     const auto end = fbb_.EndTable(start_);
6236     auto o = flatbuffers::Offset<TransposeConvOptions>(end);
6237     return o;
6238   }
6239 };
6240
6241 inline flatbuffers::Offset<TransposeConvOptions>
6242 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb,
6243                            circle::Padding padding = circle::Padding_SAME, int32_t stride_w = 0,
6244                            int32_t stride_h = 0)
6245 {
6246   TransposeConvOptionsBuilder builder_(_fbb);
6247   builder_.add_stride_h(stride_h);
6248   builder_.add_stride_w(stride_w);
6249   builder_.add_padding(padding);
6250   return builder_.Finish();
6251 }
6252
6253 struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6254 {
6255   typedef ExpandDimsOptionsBuilder Builder;
6256   bool Verify(flatbuffers::Verifier &verifier) const
6257   {
6258     return VerifyTableStart(verifier) && verifier.EndTable();
6259   }
6260 };
6261
6262 struct ExpandDimsOptionsBuilder
6263 {
6264   typedef ExpandDimsOptions Table;
6265   flatbuffers::FlatBufferBuilder &fbb_;
6266   flatbuffers::uoffset_t start_;
6267   explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6268   {
6269     start_ = fbb_.StartTable();
6270   }
6271   ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &);
6272   flatbuffers::Offset<ExpandDimsOptions> Finish()
6273   {
6274     const auto end = fbb_.EndTable(start_);
6275     auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
6276     return o;
6277   }
6278 };
6279
6280 inline flatbuffers::Offset<ExpandDimsOptions>
6281 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb)
6282 {
6283   ExpandDimsOptionsBuilder builder_(_fbb);
6284   return builder_.Finish();
6285 }
6286
6287 struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6288 {
6289   typedef SparseToDenseOptionsBuilder Builder;
6290   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6291   {
6292     VT_VALIDATE_INDICES = 4
6293   };
6294   bool validate_indices() const { return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0; }
6295   bool Verify(flatbuffers::Verifier &verifier) const
6296   {
6297     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
6298            verifier.EndTable();
6299   }
6300 };
6301
6302 struct SparseToDenseOptionsBuilder
6303 {
6304   typedef SparseToDenseOptions Table;
6305   flatbuffers::FlatBufferBuilder &fbb_;
6306   flatbuffers::uoffset_t start_;
6307   void add_validate_indices(bool validate_indices)
6308   {
6309     fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES,
6310                              static_cast<uint8_t>(validate_indices), 0);
6311   }
6312   explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6313   {
6314     start_ = fbb_.StartTable();
6315   }
6316   SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &);
6317   flatbuffers::Offset<SparseToDenseOptions> Finish()
6318   {
6319     const auto end = fbb_.EndTable(start_);
6320     auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
6321     return o;
6322   }
6323 };
6324
6325 inline flatbuffers::Offset<SparseToDenseOptions>
6326 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices = false)
6327 {
6328   SparseToDenseOptionsBuilder builder_(_fbb);
6329   builder_.add_validate_indices(validate_indices);
6330   return builder_.Finish();
6331 }
6332
6333 struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6334 {
6335   typedef EqualOptionsBuilder Builder;
6336   bool Verify(flatbuffers::Verifier &verifier) const
6337   {
6338     return VerifyTableStart(verifier) && verifier.EndTable();
6339   }
6340 };
6341
6342 struct EqualOptionsBuilder
6343 {
6344   typedef EqualOptions Table;
6345   flatbuffers::FlatBufferBuilder &fbb_;
6346   flatbuffers::uoffset_t start_;
6347   explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6348   {
6349     start_ = fbb_.StartTable();
6350   }
6351   EqualOptionsBuilder &operator=(const EqualOptionsBuilder &);
6352   flatbuffers::Offset<EqualOptions> Finish()
6353   {
6354     const auto end = fbb_.EndTable(start_);
6355     auto o = flatbuffers::Offset<EqualOptions>(end);
6356     return o;
6357   }
6358 };
6359
6360 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6361 {
6362   EqualOptionsBuilder builder_(_fbb);
6363   return builder_.Finish();
6364 }
6365
6366 struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6367 {
6368   typedef NotEqualOptionsBuilder Builder;
6369   bool Verify(flatbuffers::Verifier &verifier) const
6370   {
6371     return VerifyTableStart(verifier) && verifier.EndTable();
6372   }
6373 };
6374
6375 struct NotEqualOptionsBuilder
6376 {
6377   typedef NotEqualOptions Table;
6378   flatbuffers::FlatBufferBuilder &fbb_;
6379   flatbuffers::uoffset_t start_;
6380   explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6381   {
6382     start_ = fbb_.StartTable();
6383   }
6384   NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &);
6385   flatbuffers::Offset<NotEqualOptions> Finish()
6386   {
6387     const auto end = fbb_.EndTable(start_);
6388     auto o = flatbuffers::Offset<NotEqualOptions>(end);
6389     return o;
6390   }
6391 };
6392
6393 inline flatbuffers::Offset<NotEqualOptions>
6394 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
6395 {
6396   NotEqualOptionsBuilder builder_(_fbb);
6397   return builder_.Finish();
6398 }
6399
6400 struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6401 {
6402   typedef ShapeOptionsBuilder Builder;
6403   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6404   {
6405     VT_OUT_TYPE = 4
6406   };
6407   circle::TensorType out_type() const
6408   {
6409     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
6410   }
6411   bool Verify(flatbuffers::Verifier &verifier) const
6412   {
6413     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
6414            verifier.EndTable();
6415   }
6416 };
6417
6418 struct ShapeOptionsBuilder
6419 {
6420   typedef ShapeOptions Table;
6421   flatbuffers::FlatBufferBuilder &fbb_;
6422   flatbuffers::uoffset_t start_;
6423   void add_out_type(circle::TensorType out_type)
6424   {
6425     fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
6426   }
6427   explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6428   {
6429     start_ = fbb_.StartTable();
6430   }
6431   ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &);
6432   flatbuffers::Offset<ShapeOptions> Finish()
6433   {
6434     const auto end = fbb_.EndTable(start_);
6435     auto o = flatbuffers::Offset<ShapeOptions>(end);
6436     return o;
6437   }
6438 };
6439
6440 inline flatbuffers::Offset<ShapeOptions>
6441 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
6442                    circle::TensorType out_type = circle::TensorType_FLOAT32)
6443 {
6444   ShapeOptionsBuilder builder_(_fbb);
6445   builder_.add_out_type(out_type);
6446   return builder_.Finish();
6447 }
6448
6449 struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6450 {
6451   typedef RankOptionsBuilder Builder;
6452   bool Verify(flatbuffers::Verifier &verifier) const
6453   {
6454     return VerifyTableStart(verifier) && verifier.EndTable();
6455   }
6456 };
6457
6458 struct RankOptionsBuilder
6459 {
6460   typedef RankOptions Table;
6461   flatbuffers::FlatBufferBuilder &fbb_;
6462   flatbuffers::uoffset_t start_;
6463   explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6464   {
6465     start_ = fbb_.StartTable();
6466   }
6467   RankOptionsBuilder &operator=(const RankOptionsBuilder &);
6468   flatbuffers::Offset<RankOptions> Finish()
6469   {
6470     const auto end = fbb_.EndTable(start_);
6471     auto o = flatbuffers::Offset<RankOptions>(end);
6472     return o;
6473   }
6474 };
6475
6476 inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb)
6477 {
6478   RankOptionsBuilder builder_(_fbb);
6479   return builder_.Finish();
6480 }
6481
6482 struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6483 {
6484   typedef PowOptionsBuilder Builder;
6485   bool Verify(flatbuffers::Verifier &verifier) const
6486   {
6487     return VerifyTableStart(verifier) && verifier.EndTable();
6488   }
6489 };
6490
6491 struct PowOptionsBuilder
6492 {
6493   typedef PowOptions Table;
6494   flatbuffers::FlatBufferBuilder &fbb_;
6495   flatbuffers::uoffset_t start_;
6496   explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6497   {
6498     start_ = fbb_.StartTable();
6499   }
6500   PowOptionsBuilder &operator=(const PowOptionsBuilder &);
6501   flatbuffers::Offset<PowOptions> Finish()
6502   {
6503     const auto end = fbb_.EndTable(start_);
6504     auto o = flatbuffers::Offset<PowOptions>(end);
6505     return o;
6506   }
6507 };
6508
6509 inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb)
6510 {
6511   PowOptionsBuilder builder_(_fbb);
6512   return builder_.Finish();
6513 }
6514
6515 struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6516 {
6517   typedef FakeQuantOptionsBuilder Builder;
6518   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6519   {
6520     VT_MIN = 4,
6521     VT_MAX = 6,
6522     VT_NUM_BITS = 8,
6523     VT_NARROW_RANGE = 10
6524   };
6525   float min() const { return GetField<float>(VT_MIN, 0.0f); }
6526   float max() const { return GetField<float>(VT_MAX, 0.0f); }
6527   int32_t num_bits() const { return GetField<int32_t>(VT_NUM_BITS, 0); }
6528   bool narrow_range() const { return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0; }
6529   bool Verify(flatbuffers::Verifier &verifier) const
6530   {
6531     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_MIN) &&
6532            VerifyField<float>(verifier, VT_MAX) && VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
6533            VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) && verifier.EndTable();
6534   }
6535 };
6536
6537 struct FakeQuantOptionsBuilder
6538 {
6539   typedef FakeQuantOptions Table;
6540   flatbuffers::FlatBufferBuilder &fbb_;
6541   flatbuffers::uoffset_t start_;
6542   void add_min(float min) { fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f); }
6543   void add_max(float max) { fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f); }
6544   void add_num_bits(int32_t num_bits)
6545   {
6546     fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
6547   }
6548   void add_narrow_range(bool narrow_range)
6549   {
6550     fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range),
6551                              0);
6552   }
6553   explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6554   {
6555     start_ = fbb_.StartTable();
6556   }
6557   FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &);
6558   flatbuffers::Offset<FakeQuantOptions> Finish()
6559   {
6560     const auto end = fbb_.EndTable(start_);
6561     auto o = flatbuffers::Offset<FakeQuantOptions>(end);
6562     return o;
6563   }
6564 };
6565
6566 inline flatbuffers::Offset<FakeQuantOptions>
6567 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, float min = 0.0f, float max = 0.0f,
6568                        int32_t num_bits = 0, bool narrow_range = false)
6569 {
6570   FakeQuantOptionsBuilder builder_(_fbb);
6571   builder_.add_num_bits(num_bits);
6572   builder_.add_max(max);
6573   builder_.add_min(min);
6574   builder_.add_narrow_range(narrow_range);
6575   return builder_.Finish();
6576 }
6577
6578 struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6579 {
6580   typedef PackOptionsBuilder Builder;
6581   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6582   {
6583     VT_VALUES_COUNT = 4,
6584     VT_AXIS = 6
6585   };
6586   int32_t values_count() const { return GetField<int32_t>(VT_VALUES_COUNT, 0); }
6587   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6588   bool Verify(flatbuffers::Verifier &verifier) const
6589   {
6590     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
6591            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
6592   }
6593 };
6594
6595 struct PackOptionsBuilder
6596 {
6597   typedef PackOptions Table;
6598   flatbuffers::FlatBufferBuilder &fbb_;
6599   flatbuffers::uoffset_t start_;
6600   void add_values_count(int32_t values_count)
6601   {
6602     fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
6603   }
6604   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0); }
6605   explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6606   {
6607     start_ = fbb_.StartTable();
6608   }
6609   PackOptionsBuilder &operator=(const PackOptionsBuilder &);
6610   flatbuffers::Offset<PackOptions> Finish()
6611   {
6612     const auto end = fbb_.EndTable(start_);
6613     auto o = flatbuffers::Offset<PackOptions>(end);
6614     return o;
6615   }
6616 };
6617
6618 inline flatbuffers::Offset<PackOptions>
6619 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count = 0, int32_t axis = 0)
6620 {
6621   PackOptionsBuilder builder_(_fbb);
6622   builder_.add_axis(axis);
6623   builder_.add_values_count(values_count);
6624   return builder_.Finish();
6625 }
6626
6627 struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6628 {
6629   typedef LogicalOrOptionsBuilder Builder;
6630   bool Verify(flatbuffers::Verifier &verifier) const
6631   {
6632     return VerifyTableStart(verifier) && verifier.EndTable();
6633   }
6634 };
6635
6636 struct LogicalOrOptionsBuilder
6637 {
6638   typedef LogicalOrOptions Table;
6639   flatbuffers::FlatBufferBuilder &fbb_;
6640   flatbuffers::uoffset_t start_;
6641   explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6642   {
6643     start_ = fbb_.StartTable();
6644   }
6645   LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &);
6646   flatbuffers::Offset<LogicalOrOptions> Finish()
6647   {
6648     const auto end = fbb_.EndTable(start_);
6649     auto o = flatbuffers::Offset<LogicalOrOptions>(end);
6650     return o;
6651   }
6652 };
6653
6654 inline flatbuffers::Offset<LogicalOrOptions>
6655 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb)
6656 {
6657   LogicalOrOptionsBuilder builder_(_fbb);
6658   return builder_.Finish();
6659 }
6660
6661 struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6662 {
6663   typedef OneHotOptionsBuilder Builder;
6664   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6665   {
6666     VT_AXIS = 4
6667   };
6668   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6669   bool Verify(flatbuffers::Verifier &verifier) const
6670   {
6671     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
6672            verifier.EndTable();
6673   }
6674 };
6675
6676 struct OneHotOptionsBuilder
6677 {
6678   typedef OneHotOptions Table;
6679   flatbuffers::FlatBufferBuilder &fbb_;
6680   flatbuffers::uoffset_t start_;
6681   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0); }
6682   explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6683   {
6684     start_ = fbb_.StartTable();
6685   }
6686   OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &);
6687   flatbuffers::Offset<OneHotOptions> Finish()
6688   {
6689     const auto end = fbb_.EndTable(start_);
6690     auto o = flatbuffers::Offset<OneHotOptions>(end);
6691     return o;
6692   }
6693 };
6694
6695 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb,
6696                                                               int32_t axis = 0)
6697 {
6698   OneHotOptionsBuilder builder_(_fbb);
6699   builder_.add_axis(axis);
6700   return builder_.Finish();
6701 }
6702
6703 struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6704 {
6705   typedef AbsOptionsBuilder Builder;
6706   bool Verify(flatbuffers::Verifier &verifier) const
6707   {
6708     return VerifyTableStart(verifier) && verifier.EndTable();
6709   }
6710 };
6711
6712 struct AbsOptionsBuilder
6713 {
6714   typedef AbsOptions Table;
6715   flatbuffers::FlatBufferBuilder &fbb_;
6716   flatbuffers::uoffset_t start_;
6717   explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6718   {
6719     start_ = fbb_.StartTable();
6720   }
6721   AbsOptionsBuilder &operator=(const AbsOptionsBuilder &);
6722   flatbuffers::Offset<AbsOptions> Finish()
6723   {
6724     const auto end = fbb_.EndTable(start_);
6725     auto o = flatbuffers::Offset<AbsOptions>(end);
6726     return o;
6727   }
6728 };
6729
6730 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb)
6731 {
6732   AbsOptionsBuilder builder_(_fbb);
6733   return builder_.Finish();
6734 }
6735
6736 struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6737 {
6738   typedef HardSwishOptionsBuilder Builder;
6739   bool Verify(flatbuffers::Verifier &verifier) const
6740   {
6741     return VerifyTableStart(verifier) && verifier.EndTable();
6742   }
6743 };
6744
6745 struct HardSwishOptionsBuilder
6746 {
6747   typedef HardSwishOptions Table;
6748   flatbuffers::FlatBufferBuilder &fbb_;
6749   flatbuffers::uoffset_t start_;
6750   explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6751   {
6752     start_ = fbb_.StartTable();
6753   }
6754   HardSwishOptionsBuilder &operator=(const HardSwishOptionsBuilder &);
6755   flatbuffers::Offset<HardSwishOptions> Finish()
6756   {
6757     const auto end = fbb_.EndTable(start_);
6758     auto o = flatbuffers::Offset<HardSwishOptions>(end);
6759     return o;
6760   }
6761 };
6762
6763 inline flatbuffers::Offset<HardSwishOptions>
6764 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb)
6765 {
6766   HardSwishOptionsBuilder builder_(_fbb);
6767   return builder_.Finish();
6768 }
6769
6770 struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6771 {
6772   typedef LogicalAndOptionsBuilder Builder;
6773   bool Verify(flatbuffers::Verifier &verifier) const
6774   {
6775     return VerifyTableStart(verifier) && verifier.EndTable();
6776   }
6777 };
6778
6779 struct LogicalAndOptionsBuilder
6780 {
6781   typedef LogicalAndOptions Table;
6782   flatbuffers::FlatBufferBuilder &fbb_;
6783   flatbuffers::uoffset_t start_;
6784   explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6785   {
6786     start_ = fbb_.StartTable();
6787   }
6788   LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &);
6789   flatbuffers::Offset<LogicalAndOptions> Finish()
6790   {
6791     const auto end = fbb_.EndTable(start_);
6792     auto o = flatbuffers::Offset<LogicalAndOptions>(end);
6793     return o;
6794   }
6795 };
6796
6797 inline flatbuffers::Offset<LogicalAndOptions>
6798 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb)
6799 {
6800   LogicalAndOptionsBuilder builder_(_fbb);
6801   return builder_.Finish();
6802 }
6803
6804 struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6805 {
6806   typedef LogicalNotOptionsBuilder Builder;
6807   bool Verify(flatbuffers::Verifier &verifier) const
6808   {
6809     return VerifyTableStart(verifier) && verifier.EndTable();
6810   }
6811 };
6812
6813 struct LogicalNotOptionsBuilder
6814 {
6815   typedef LogicalNotOptions Table;
6816   flatbuffers::FlatBufferBuilder &fbb_;
6817   flatbuffers::uoffset_t start_;
6818   explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6819   {
6820     start_ = fbb_.StartTable();
6821   }
6822   LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &);
6823   flatbuffers::Offset<LogicalNotOptions> Finish()
6824   {
6825     const auto end = fbb_.EndTable(start_);
6826     auto o = flatbuffers::Offset<LogicalNotOptions>(end);
6827     return o;
6828   }
6829 };
6830
6831 inline flatbuffers::Offset<LogicalNotOptions>
6832 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb)
6833 {
6834   LogicalNotOptionsBuilder builder_(_fbb);
6835   return builder_.Finish();
6836 }
6837
6838 struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6839 {
6840   typedef UnpackOptionsBuilder Builder;
6841   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6842   {
6843     VT_NUM = 4,
6844     VT_AXIS = 6
6845   };
6846   int32_t num() const { return GetField<int32_t>(VT_NUM, 0); }
6847   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6848   bool Verify(flatbuffers::Verifier &verifier) const
6849   {
6850     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM) &&
6851            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
6852   }
6853 };
6854
6855 struct UnpackOptionsBuilder
6856 {
6857   typedef UnpackOptions Table;
6858   flatbuffers::FlatBufferBuilder &fbb_;
6859   flatbuffers::uoffset_t start_;
6860   void add_num(int32_t num) { fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0); }
6861   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0); }
6862   explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6863   {
6864     start_ = fbb_.StartTable();
6865   }
6866   UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &);
6867   flatbuffers::Offset<UnpackOptions> Finish()
6868   {
6869     const auto end = fbb_.EndTable(start_);
6870     auto o = flatbuffers::Offset<UnpackOptions>(end);
6871     return o;
6872   }
6873 };
6874
6875 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb,
6876                                                               int32_t num = 0, int32_t axis = 0)
6877 {
6878   UnpackOptionsBuilder builder_(_fbb);
6879   builder_.add_axis(axis);
6880   builder_.add_num(num);
6881   return builder_.Finish();
6882 }
6883
6884 struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6885 {
6886   typedef FloorDivOptionsBuilder Builder;
6887   bool Verify(flatbuffers::Verifier &verifier) const
6888   {
6889     return VerifyTableStart(verifier) && verifier.EndTable();
6890   }
6891 };
6892
6893 struct FloorDivOptionsBuilder
6894 {
6895   typedef FloorDivOptions Table;
6896   flatbuffers::FlatBufferBuilder &fbb_;
6897   flatbuffers::uoffset_t start_;
6898   explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6899   {
6900     start_ = fbb_.StartTable();
6901   }
6902   FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &);
6903   flatbuffers::Offset<FloorDivOptions> Finish()
6904   {
6905     const auto end = fbb_.EndTable(start_);
6906     auto o = flatbuffers::Offset<FloorDivOptions>(end);
6907     return o;
6908   }
6909 };
6910
6911 inline flatbuffers::Offset<FloorDivOptions>
6912 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb)
6913 {
6914   FloorDivOptionsBuilder builder_(_fbb);
6915   return builder_.Finish();
6916 }
6917
6918 struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6919 {
6920   typedef SquareOptionsBuilder Builder;
6921   bool Verify(flatbuffers::Verifier &verifier) const
6922   {
6923     return VerifyTableStart(verifier) && verifier.EndTable();
6924   }
6925 };
6926
6927 struct SquareOptionsBuilder
6928 {
6929   typedef SquareOptions Table;
6930   flatbuffers::FlatBufferBuilder &fbb_;
6931   flatbuffers::uoffset_t start_;
6932   explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6933   {
6934     start_ = fbb_.StartTable();
6935   }
6936   SquareOptionsBuilder &operator=(const SquareOptionsBuilder &);
6937   flatbuffers::Offset<SquareOptions> Finish()
6938   {
6939     const auto end = fbb_.EndTable(start_);
6940     auto o = flatbuffers::Offset<SquareOptions>(end);
6941     return o;
6942   }
6943 };
6944
6945 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb)
6946 {
6947   SquareOptionsBuilder builder_(_fbb);
6948   return builder_.Finish();
6949 }
6950
6951 struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6952 {
6953   typedef ZerosLikeOptionsBuilder Builder;
6954   bool Verify(flatbuffers::Verifier &verifier) const
6955   {
6956     return VerifyTableStart(verifier) && verifier.EndTable();
6957   }
6958 };
6959
6960 struct ZerosLikeOptionsBuilder
6961 {
6962   typedef ZerosLikeOptions Table;
6963   flatbuffers::FlatBufferBuilder &fbb_;
6964   flatbuffers::uoffset_t start_;
6965   explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6966   {
6967     start_ = fbb_.StartTable();
6968   }
6969   ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &);
6970   flatbuffers::Offset<ZerosLikeOptions> Finish()
6971   {
6972     const auto end = fbb_.EndTable(start_);
6973     auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
6974     return o;
6975   }
6976 };
6977
6978 inline flatbuffers::Offset<ZerosLikeOptions>
6979 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb)
6980 {
6981   ZerosLikeOptionsBuilder builder_(_fbb);
6982   return builder_.Finish();
6983 }
6984
6985 struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6986 {
6987   typedef FillOptionsBuilder Builder;
6988   bool Verify(flatbuffers::Verifier &verifier) const
6989   {
6990     return VerifyTableStart(verifier) && verifier.EndTable();
6991   }
6992 };
6993
6994 struct FillOptionsBuilder
6995 {
6996   typedef FillOptions Table;
6997   flatbuffers::FlatBufferBuilder &fbb_;
6998   flatbuffers::uoffset_t start_;
6999   explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7000   {
7001     start_ = fbb_.StartTable();
7002   }
7003   FillOptionsBuilder &operator=(const FillOptionsBuilder &);
7004   flatbuffers::Offset<FillOptions> Finish()
7005   {
7006     const auto end = fbb_.EndTable(start_);
7007     auto o = flatbuffers::Offset<FillOptions>(end);
7008     return o;
7009   }
7010 };
7011
7012 inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb)
7013 {
7014   FillOptionsBuilder builder_(_fbb);
7015   return builder_.Finish();
7016 }
7017
7018 struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7019 {
7020   typedef FloorModOptionsBuilder Builder;
7021   bool Verify(flatbuffers::Verifier &verifier) const
7022   {
7023     return VerifyTableStart(verifier) && verifier.EndTable();
7024   }
7025 };
7026
7027 struct FloorModOptionsBuilder
7028 {
7029   typedef FloorModOptions Table;
7030   flatbuffers::FlatBufferBuilder &fbb_;
7031   flatbuffers::uoffset_t start_;
7032   explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7033   {
7034     start_ = fbb_.StartTable();
7035   }
7036   FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &);
7037   flatbuffers::Offset<FloorModOptions> Finish()
7038   {
7039     const auto end = fbb_.EndTable(start_);
7040     auto o = flatbuffers::Offset<FloorModOptions>(end);
7041     return o;
7042   }
7043 };
7044
7045 inline flatbuffers::Offset<FloorModOptions>
7046 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb)
7047 {
7048   FloorModOptionsBuilder builder_(_fbb);
7049   return builder_.Finish();
7050 }
7051
7052 struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7053 {
7054   typedef RangeOptionsBuilder Builder;
7055   bool Verify(flatbuffers::Verifier &verifier) const
7056   {
7057     return VerifyTableStart(verifier) && verifier.EndTable();
7058   }
7059 };
7060
7061 struct RangeOptionsBuilder
7062 {
7063   typedef RangeOptions Table;
7064   flatbuffers::FlatBufferBuilder &fbb_;
7065   flatbuffers::uoffset_t start_;
7066   explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7067   {
7068     start_ = fbb_.StartTable();
7069   }
7070   RangeOptionsBuilder &operator=(const RangeOptionsBuilder &);
7071   flatbuffers::Offset<RangeOptions> Finish()
7072   {
7073     const auto end = fbb_.EndTable(start_);
7074     auto o = flatbuffers::Offset<RangeOptions>(end);
7075     return o;
7076   }
7077 };
7078
7079 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb)
7080 {
7081   RangeOptionsBuilder builder_(_fbb);
7082   return builder_.Finish();
7083 }
7084
7085 struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7086 {
7087   typedef LeakyReluOptionsBuilder Builder;
7088   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7089   {
7090     VT_ALPHA = 4
7091   };
7092   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
7093   bool Verify(flatbuffers::Verifier &verifier) const
7094   {
7095     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_ALPHA) &&
7096            verifier.EndTable();
7097   }
7098 };
7099
7100 struct LeakyReluOptionsBuilder
7101 {
7102   typedef LeakyReluOptions Table;
7103   flatbuffers::FlatBufferBuilder &fbb_;
7104   flatbuffers::uoffset_t start_;
7105   void add_alpha(float alpha) { fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); }
7106   explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7107   {
7108     start_ = fbb_.StartTable();
7109   }
7110   LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &);
7111   flatbuffers::Offset<LeakyReluOptions> Finish()
7112   {
7113     const auto end = fbb_.EndTable(start_);
7114     auto o = flatbuffers::Offset<LeakyReluOptions>(end);
7115     return o;
7116   }
7117 };
7118
7119 inline flatbuffers::Offset<LeakyReluOptions>
7120 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, float alpha = 0.0f)
7121 {
7122   LeakyReluOptionsBuilder builder_(_fbb);
7123   builder_.add_alpha(alpha);
7124   return builder_.Finish();
7125 }
7126
7127 struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7128 {
7129   typedef SquaredDifferenceOptionsBuilder Builder;
7130   bool Verify(flatbuffers::Verifier &verifier) const
7131   {
7132     return VerifyTableStart(verifier) && verifier.EndTable();
7133   }
7134 };
7135
7136 struct SquaredDifferenceOptionsBuilder
7137 {
7138   typedef SquaredDifferenceOptions Table;
7139   flatbuffers::FlatBufferBuilder &fbb_;
7140   flatbuffers::uoffset_t start_;
7141   explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7142   {
7143     start_ = fbb_.StartTable();
7144   }
7145   SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &);
7146   flatbuffers::Offset<SquaredDifferenceOptions> Finish()
7147   {
7148     const auto end = fbb_.EndTable(start_);
7149     auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
7150     return o;
7151   }
7152 };
7153
7154 inline flatbuffers::Offset<SquaredDifferenceOptions>
7155 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb)
7156 {
7157   SquaredDifferenceOptionsBuilder builder_(_fbb);
7158   return builder_.Finish();
7159 }
7160
7161 struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7162 {
7163   typedef MirrorPadOptionsBuilder Builder;
7164   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7165   {
7166     VT_MODE = 4
7167   };
7168   circle::MirrorPadMode mode() const
7169   {
7170     return static_cast<circle::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
7171   }
7172   bool Verify(flatbuffers::Verifier &verifier) const
7173   {
7174     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_MODE) &&
7175            verifier.EndTable();
7176   }
7177 };
7178
7179 struct MirrorPadOptionsBuilder
7180 {
7181   typedef MirrorPadOptions Table;
7182   flatbuffers::FlatBufferBuilder &fbb_;
7183   flatbuffers::uoffset_t start_;
7184   void add_mode(circle::MirrorPadMode mode)
7185   {
7186     fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
7187   }
7188   explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7189   {
7190     start_ = fbb_.StartTable();
7191   }
7192   MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &);
7193   flatbuffers::Offset<MirrorPadOptions> Finish()
7194   {
7195     const auto end = fbb_.EndTable(start_);
7196     auto o = flatbuffers::Offset<MirrorPadOptions>(end);
7197     return o;
7198   }
7199 };
7200
7201 inline flatbuffers::Offset<MirrorPadOptions>
7202 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb,
7203                        circle::MirrorPadMode mode = circle::MirrorPadMode_REFLECT)
7204 {
7205   MirrorPadOptionsBuilder builder_(_fbb);
7206   builder_.add_mode(mode);
7207   return builder_.Finish();
7208 }
7209
7210 struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7211 {
7212   typedef UniqueOptionsBuilder Builder;
7213   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7214   {
7215     VT_IDX_OUT_TYPE = 4
7216   };
7217   circle::TensorType idx_out_type() const
7218   {
7219     return static_cast<circle::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
7220   }
7221   bool Verify(flatbuffers::Verifier &verifier) const
7222   {
7223     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
7224            verifier.EndTable();
7225   }
7226 };
7227
7228 struct UniqueOptionsBuilder
7229 {
7230   typedef UniqueOptions Table;
7231   flatbuffers::FlatBufferBuilder &fbb_;
7232   flatbuffers::uoffset_t start_;
7233   void add_idx_out_type(circle::TensorType idx_out_type)
7234   {
7235     fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
7236   }
7237   explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7238   {
7239     start_ = fbb_.StartTable();
7240   }
7241   UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &);
7242   flatbuffers::Offset<UniqueOptions> Finish()
7243   {
7244     const auto end = fbb_.EndTable(start_);
7245     auto o = flatbuffers::Offset<UniqueOptions>(end);
7246     return o;
7247   }
7248 };
7249
7250 inline flatbuffers::Offset<UniqueOptions>
7251 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb,
7252                     circle::TensorType idx_out_type = circle::TensorType_INT32)
7253 {
7254   UniqueOptionsBuilder builder_(_fbb);
7255   builder_.add_idx_out_type(idx_out_type);
7256   return builder_.Finish();
7257 }
7258
7259 struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7260 {
7261   typedef ReverseV2OptionsBuilder Builder;
7262   bool Verify(flatbuffers::Verifier &verifier) const
7263   {
7264     return VerifyTableStart(verifier) && verifier.EndTable();
7265   }
7266 };
7267
7268 struct ReverseV2OptionsBuilder
7269 {
7270   typedef ReverseV2Options Table;
7271   flatbuffers::FlatBufferBuilder &fbb_;
7272   flatbuffers::uoffset_t start_;
7273   explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7274   {
7275     start_ = fbb_.StartTable();
7276   }
7277   ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &);
7278   flatbuffers::Offset<ReverseV2Options> Finish()
7279   {
7280     const auto end = fbb_.EndTable(start_);
7281     auto o = flatbuffers::Offset<ReverseV2Options>(end);
7282     return o;
7283   }
7284 };
7285
7286 inline flatbuffers::Offset<ReverseV2Options>
7287 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7288 {
7289   ReverseV2OptionsBuilder builder_(_fbb);
7290   return builder_.Finish();
7291 }
7292
7293 struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7294 {
7295   typedef AddNOptionsBuilder Builder;
7296   bool Verify(flatbuffers::Verifier &verifier) const
7297   {
7298     return VerifyTableStart(verifier) && verifier.EndTable();
7299   }
7300 };
7301
7302 struct AddNOptionsBuilder
7303 {
7304   typedef AddNOptions Table;
7305   flatbuffers::FlatBufferBuilder &fbb_;
7306   flatbuffers::uoffset_t start_;
7307   explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7308   {
7309     start_ = fbb_.StartTable();
7310   }
7311   AddNOptionsBuilder &operator=(const AddNOptionsBuilder &);
7312   flatbuffers::Offset<AddNOptions> Finish()
7313   {
7314     const auto end = fbb_.EndTable(start_);
7315     auto o = flatbuffers::Offset<AddNOptions>(end);
7316     return o;
7317   }
7318 };
7319
7320 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb)
7321 {
7322   AddNOptionsBuilder builder_(_fbb);
7323   return builder_.Finish();
7324 }
7325
7326 struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7327 {
7328   typedef GatherNdOptionsBuilder Builder;
7329   bool Verify(flatbuffers::Verifier &verifier) const
7330   {
7331     return VerifyTableStart(verifier) && verifier.EndTable();
7332   }
7333 };
7334
7335 struct GatherNdOptionsBuilder
7336 {
7337   typedef GatherNdOptions Table;
7338   flatbuffers::FlatBufferBuilder &fbb_;
7339   flatbuffers::uoffset_t start_;
7340   explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7341   {
7342     start_ = fbb_.StartTable();
7343   }
7344   GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &);
7345   flatbuffers::Offset<GatherNdOptions> Finish()
7346   {
7347     const auto end = fbb_.EndTable(start_);
7348     auto o = flatbuffers::Offset<GatherNdOptions>(end);
7349     return o;
7350   }
7351 };
7352
7353 inline flatbuffers::Offset<GatherNdOptions>
7354 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
7355 {
7356   GatherNdOptionsBuilder builder_(_fbb);
7357   return builder_.Finish();
7358 }
7359
7360 struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7361 {
7362   typedef WhereOptionsBuilder Builder;
7363   bool Verify(flatbuffers::Verifier &verifier) const
7364   {
7365     return VerifyTableStart(verifier) && verifier.EndTable();
7366   }
7367 };
7368
7369 struct WhereOptionsBuilder
7370 {
7371   typedef WhereOptions Table;
7372   flatbuffers::FlatBufferBuilder &fbb_;
7373   flatbuffers::uoffset_t start_;
7374   explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7375   {
7376     start_ = fbb_.StartTable();
7377   }
7378   WhereOptionsBuilder &operator=(const WhereOptionsBuilder &);
7379   flatbuffers::Offset<WhereOptions> Finish()
7380   {
7381     const auto end = fbb_.EndTable(start_);
7382     auto o = flatbuffers::Offset<WhereOptions>(end);
7383     return o;
7384   }
7385 };
7386
7387 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb)
7388 {
7389   WhereOptionsBuilder builder_(_fbb);
7390   return builder_.Finish();
7391 }
7392
7393 struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7394 {
7395   typedef ReverseSequenceOptionsBuilder Builder;
7396   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7397   {
7398     VT_SEQ_DIM = 4,
7399     VT_BATCH_DIM = 6
7400   };
7401   int32_t seq_dim() const { return GetField<int32_t>(VT_SEQ_DIM, 0); }
7402   int32_t batch_dim() const { return GetField<int32_t>(VT_BATCH_DIM, 0); }
7403   bool Verify(flatbuffers::Verifier &verifier) const
7404   {
7405     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
7406            VerifyField<int32_t>(verifier, VT_BATCH_DIM) && verifier.EndTable();
7407   }
7408 };
7409
7410 struct ReverseSequenceOptionsBuilder
7411 {
7412   typedef ReverseSequenceOptions Table;
7413   flatbuffers::FlatBufferBuilder &fbb_;
7414   flatbuffers::uoffset_t start_;
7415   void add_seq_dim(int32_t seq_dim)
7416   {
7417     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
7418   }
7419   void add_batch_dim(int32_t batch_dim)
7420   {
7421     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
7422   }
7423   explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7424   {
7425     start_ = fbb_.StartTable();
7426   }
7427   ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &);
7428   flatbuffers::Offset<ReverseSequenceOptions> Finish()
7429   {
7430     const auto end = fbb_.EndTable(start_);
7431     auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
7432     return o;
7433   }
7434 };
7435
7436 inline flatbuffers::Offset<ReverseSequenceOptions>
7437 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim = 0,
7438                              int32_t batch_dim = 0)
7439 {
7440   ReverseSequenceOptionsBuilder builder_(_fbb);
7441   builder_.add_batch_dim(batch_dim);
7442   builder_.add_seq_dim(seq_dim);
7443   return builder_.Finish();
7444 }
7445
7446 struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7447 {
7448   typedef MatrixDiagOptionsBuilder Builder;
7449   bool Verify(flatbuffers::Verifier &verifier) const
7450   {
7451     return VerifyTableStart(verifier) && verifier.EndTable();
7452   }
7453 };
7454
7455 struct MatrixDiagOptionsBuilder
7456 {
7457   typedef MatrixDiagOptions Table;
7458   flatbuffers::FlatBufferBuilder &fbb_;
7459   flatbuffers::uoffset_t start_;
7460   explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7461   {
7462     start_ = fbb_.StartTable();
7463   }
7464   MatrixDiagOptionsBuilder &operator=(const MatrixDiagOptionsBuilder &);
7465   flatbuffers::Offset<MatrixDiagOptions> Finish()
7466   {
7467     const auto end = fbb_.EndTable(start_);
7468     auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
7469     return o;
7470   }
7471 };
7472
7473 inline flatbuffers::Offset<MatrixDiagOptions>
7474 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
7475 {
7476   MatrixDiagOptionsBuilder builder_(_fbb);
7477   return builder_.Finish();
7478 }
7479
7480 struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7481 {
7482   typedef QuantizeOptionsBuilder Builder;
7483   bool Verify(flatbuffers::Verifier &verifier) const
7484   {
7485     return VerifyTableStart(verifier) && verifier.EndTable();
7486   }
7487 };
7488
7489 struct QuantizeOptionsBuilder
7490 {
7491   typedef QuantizeOptions Table;
7492   flatbuffers::FlatBufferBuilder &fbb_;
7493   flatbuffers::uoffset_t start_;
7494   explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7495   {
7496     start_ = fbb_.StartTable();
7497   }
7498   QuantizeOptionsBuilder &operator=(const QuantizeOptionsBuilder &);
7499   flatbuffers::Offset<QuantizeOptions> Finish()
7500   {
7501     const auto end = fbb_.EndTable(start_);
7502     auto o = flatbuffers::Offset<QuantizeOptions>(end);
7503     return o;
7504   }
7505 };
7506
7507 inline flatbuffers::Offset<QuantizeOptions>
7508 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
7509 {
7510   QuantizeOptionsBuilder builder_(_fbb);
7511   return builder_.Finish();
7512 }
7513
7514 struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7515 {
7516   typedef MatrixSetDiagOptionsBuilder Builder;
7517   bool Verify(flatbuffers::Verifier &verifier) const
7518   {
7519     return VerifyTableStart(verifier) && verifier.EndTable();
7520   }
7521 };
7522
7523 struct MatrixSetDiagOptionsBuilder
7524 {
7525   typedef MatrixSetDiagOptions Table;
7526   flatbuffers::FlatBufferBuilder &fbb_;
7527   flatbuffers::uoffset_t start_;
7528   explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7529   {
7530     start_ = fbb_.StartTable();
7531   }
7532   MatrixSetDiagOptionsBuilder &operator=(const MatrixSetDiagOptionsBuilder &);
7533   flatbuffers::Offset<MatrixSetDiagOptions> Finish()
7534   {
7535     const auto end = fbb_.EndTable(start_);
7536     auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
7537     return o;
7538   }
7539 };
7540
7541 inline flatbuffers::Offset<MatrixSetDiagOptions>
7542 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
7543 {
7544   MatrixSetDiagOptionsBuilder builder_(_fbb);
7545   return builder_.Finish();
7546 }
7547
7548 struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7549 {
7550   typedef IfOptionsBuilder Builder;
7551   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7552   {
7553     VT_THEN_SUBGRAPH_INDEX = 4,
7554     VT_ELSE_SUBGRAPH_INDEX = 6
7555   };
7556   int32_t then_subgraph_index() const { return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0); }
7557   int32_t else_subgraph_index() const { return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0); }
7558   bool Verify(flatbuffers::Verifier &verifier) const
7559   {
7560     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
7561            VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) && verifier.EndTable();
7562   }
7563 };
7564
7565 struct IfOptionsBuilder
7566 {
7567   typedef IfOptions Table;
7568   flatbuffers::FlatBufferBuilder &fbb_;
7569   flatbuffers::uoffset_t start_;
7570   void add_then_subgraph_index(int32_t then_subgraph_index)
7571   {
7572     fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
7573   }
7574   void add_else_subgraph_index(int32_t else_subgraph_index)
7575   {
7576     fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
7577   }
7578   explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7579   {
7580     start_ = fbb_.StartTable();
7581   }
7582   IfOptionsBuilder &operator=(const IfOptionsBuilder &);
7583   flatbuffers::Offset<IfOptions> Finish()
7584   {
7585     const auto end = fbb_.EndTable(start_);
7586     auto o = flatbuffers::Offset<IfOptions>(end);
7587     return o;
7588   }
7589 };
7590
7591 inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb,
7592                                                       int32_t then_subgraph_index = 0,
7593                                                       int32_t else_subgraph_index = 0)
7594 {
7595   IfOptionsBuilder builder_(_fbb);
7596   builder_.add_else_subgraph_index(else_subgraph_index);
7597   builder_.add_then_subgraph_index(then_subgraph_index);
7598   return builder_.Finish();
7599 }
7600
7601 struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7602 {
7603   typedef WhileOptionsBuilder Builder;
7604   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7605   {
7606     VT_COND_SUBGRAPH_INDEX = 4,
7607     VT_BODY_SUBGRAPH_INDEX = 6
7608   };
7609   int32_t cond_subgraph_index() const { return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0); }
7610   int32_t body_subgraph_index() const { return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0); }
7611   bool Verify(flatbuffers::Verifier &verifier) const
7612   {
7613     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
7614            VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) && verifier.EndTable();
7615   }
7616 };
7617
7618 struct WhileOptionsBuilder
7619 {
7620   typedef WhileOptions Table;
7621   flatbuffers::FlatBufferBuilder &fbb_;
7622   flatbuffers::uoffset_t start_;
7623   void add_cond_subgraph_index(int32_t cond_subgraph_index)
7624   {
7625     fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
7626   }
7627   void add_body_subgraph_index(int32_t body_subgraph_index)
7628   {
7629     fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
7630   }
7631   explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7632   {
7633     start_ = fbb_.StartTable();
7634   }
7635   WhileOptionsBuilder &operator=(const WhileOptionsBuilder &);
7636   flatbuffers::Offset<WhileOptions> Finish()
7637   {
7638     const auto end = fbb_.EndTable(start_);
7639     auto o = flatbuffers::Offset<WhileOptions>(end);
7640     return o;
7641   }
7642 };
7643
7644 inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb,
7645                                                             int32_t cond_subgraph_index = 0,
7646                                                             int32_t body_subgraph_index = 0)
7647 {
7648   WhileOptionsBuilder builder_(_fbb);
7649   builder_.add_body_subgraph_index(body_subgraph_index);
7650   builder_.add_cond_subgraph_index(cond_subgraph_index);
7651   return builder_.Finish();
7652 }
7653
7654 struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7655 {
7656   typedef NonMaxSuppressionV4OptionsBuilder Builder;
7657   bool Verify(flatbuffers::Verifier &verifier) const
7658   {
7659     return VerifyTableStart(verifier) && verifier.EndTable();
7660   }
7661 };
7662
7663 struct NonMaxSuppressionV4OptionsBuilder
7664 {
7665   typedef NonMaxSuppressionV4Options Table;
7666   flatbuffers::FlatBufferBuilder &fbb_;
7667   flatbuffers::uoffset_t start_;
7668   explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7669   {
7670     start_ = fbb_.StartTable();
7671   }
7672   NonMaxSuppressionV4OptionsBuilder &operator=(const NonMaxSuppressionV4OptionsBuilder &);
7673   flatbuffers::Offset<NonMaxSuppressionV4Options> Finish()
7674   {
7675     const auto end = fbb_.EndTable(start_);
7676     auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
7677     return o;
7678   }
7679 };
7680
7681 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
7682 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb)
7683 {
7684   NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
7685   return builder_.Finish();
7686 }
7687
7688 struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7689 {
7690   typedef NonMaxSuppressionV5OptionsBuilder Builder;
7691   bool Verify(flatbuffers::Verifier &verifier) const
7692   {
7693     return VerifyTableStart(verifier) && verifier.EndTable();
7694   }
7695 };
7696
7697 struct NonMaxSuppressionV5OptionsBuilder
7698 {
7699   typedef NonMaxSuppressionV5Options Table;
7700   flatbuffers::FlatBufferBuilder &fbb_;
7701   flatbuffers::uoffset_t start_;
7702   explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7703   {
7704     start_ = fbb_.StartTable();
7705   }
7706   NonMaxSuppressionV5OptionsBuilder &operator=(const NonMaxSuppressionV5OptionsBuilder &);
7707   flatbuffers::Offset<NonMaxSuppressionV5Options> Finish()
7708   {
7709     const auto end = fbb_.EndTable(start_);
7710     auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
7711     return o;
7712   }
7713 };
7714
7715 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
7716 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb)
7717 {
7718   NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
7719   return builder_.Finish();
7720 }
7721
7722 struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7723 {
7724   typedef ScatterNdOptionsBuilder Builder;
7725   bool Verify(flatbuffers::Verifier &verifier) const
7726   {
7727     return VerifyTableStart(verifier) && verifier.EndTable();
7728   }
7729 };
7730
7731 struct ScatterNdOptionsBuilder
7732 {
7733   typedef ScatterNdOptions Table;
7734   flatbuffers::FlatBufferBuilder &fbb_;
7735   flatbuffers::uoffset_t start_;
7736   explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7737   {
7738     start_ = fbb_.StartTable();
7739   }
7740   ScatterNdOptionsBuilder &operator=(const ScatterNdOptionsBuilder &);
7741   flatbuffers::Offset<ScatterNdOptions> Finish()
7742   {
7743     const auto end = fbb_.EndTable(start_);
7744     auto o = flatbuffers::Offset<ScatterNdOptions>(end);
7745     return o;
7746   }
7747 };
7748
7749 inline flatbuffers::Offset<ScatterNdOptions>
7750 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
7751 {
7752   ScatterNdOptionsBuilder builder_(_fbb);
7753   return builder_.Finish();
7754 }
7755
7756 struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7757 {
7758   typedef SelectV2OptionsBuilder Builder;
7759   bool Verify(flatbuffers::Verifier &verifier) const
7760   {
7761     return VerifyTableStart(verifier) && verifier.EndTable();
7762   }
7763 };
7764
7765 struct SelectV2OptionsBuilder
7766 {
7767   typedef SelectV2Options Table;
7768   flatbuffers::FlatBufferBuilder &fbb_;
7769   flatbuffers::uoffset_t start_;
7770   explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7771   {
7772     start_ = fbb_.StartTable();
7773   }
7774   SelectV2OptionsBuilder &operator=(const SelectV2OptionsBuilder &);
7775   flatbuffers::Offset<SelectV2Options> Finish()
7776   {
7777     const auto end = fbb_.EndTable(start_);
7778     auto o = flatbuffers::Offset<SelectV2Options>(end);
7779     return o;
7780   }
7781 };
7782
7783 inline flatbuffers::Offset<SelectV2Options>
7784 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7785 {
7786   SelectV2OptionsBuilder builder_(_fbb);
7787   return builder_.Finish();
7788 }
7789
7790 struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7791 {
7792   typedef DensifyOptionsBuilder Builder;
7793   bool Verify(flatbuffers::Verifier &verifier) const
7794   {
7795     return VerifyTableStart(verifier) && verifier.EndTable();
7796   }
7797 };
7798
7799 struct DensifyOptionsBuilder
7800 {
7801   typedef DensifyOptions Table;
7802   flatbuffers::FlatBufferBuilder &fbb_;
7803   flatbuffers::uoffset_t start_;
7804   explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7805   {
7806     start_ = fbb_.StartTable();
7807   }
7808   DensifyOptionsBuilder &operator=(const DensifyOptionsBuilder &);
7809   flatbuffers::Offset<DensifyOptions> Finish()
7810   {
7811     const auto end = fbb_.EndTable(start_);
7812     auto o = flatbuffers::Offset<DensifyOptions>(end);
7813     return o;
7814   }
7815 };
7816
7817 inline flatbuffers::Offset<DensifyOptions>
7818 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb)
7819 {
7820   DensifyOptionsBuilder builder_(_fbb);
7821   return builder_.Finish();
7822 }
7823
7824 struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7825 {
7826   typedef SegmentSumOptionsBuilder Builder;
7827   bool Verify(flatbuffers::Verifier &verifier) const
7828   {
7829     return VerifyTableStart(verifier) && verifier.EndTable();
7830   }
7831 };
7832
7833 struct SegmentSumOptionsBuilder
7834 {
7835   typedef SegmentSumOptions Table;
7836   flatbuffers::FlatBufferBuilder &fbb_;
7837   flatbuffers::uoffset_t start_;
7838   explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7839   {
7840     start_ = fbb_.StartTable();
7841   }
7842   SegmentSumOptionsBuilder &operator=(const SegmentSumOptionsBuilder &);
7843   flatbuffers::Offset<SegmentSumOptions> Finish()
7844   {
7845     const auto end = fbb_.EndTable(start_);
7846     auto o = flatbuffers::Offset<SegmentSumOptions>(end);
7847     return o;
7848   }
7849 };
7850
7851 inline flatbuffers::Offset<SegmentSumOptions>
7852 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
7853 {
7854   SegmentSumOptionsBuilder builder_(_fbb);
7855   return builder_.Finish();
7856 }
7857
7858 struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7859 {
7860   typedef BatchMatMulOptionsBuilder Builder;
7861   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7862   {
7863     VT_ADJOINT_LHS = 4,
7864     VT_ADJOINT_RHS = 6
7865   };
7866   bool adjoint_lhs() const { return GetField<uint8_t>(VT_ADJOINT_LHS, 0) != 0; }
7867   bool adjoint_rhs() const { return GetField<uint8_t>(VT_ADJOINT_RHS, 0) != 0; }
7868   bool Verify(flatbuffers::Verifier &verifier) const
7869   {
7870     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ADJOINT_LHS) &&
7871            VerifyField<uint8_t>(verifier, VT_ADJOINT_RHS) && verifier.EndTable();
7872   }
7873 };
7874
7875 struct BatchMatMulOptionsBuilder
7876 {
7877   typedef BatchMatMulOptions Table;
7878   flatbuffers::FlatBufferBuilder &fbb_;
7879   flatbuffers::uoffset_t start_;
7880   void add_adjoint_lhs(bool adjoint_lhs)
7881   {
7882     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_LHS, static_cast<uint8_t>(adjoint_lhs),
7883                              0);
7884   }
7885   void add_adjoint_rhs(bool adjoint_rhs)
7886   {
7887     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_RHS, static_cast<uint8_t>(adjoint_rhs),
7888                              0);
7889   }
7890   explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7891   {
7892     start_ = fbb_.StartTable();
7893   }
7894   BatchMatMulOptionsBuilder &operator=(const BatchMatMulOptionsBuilder &);
7895   flatbuffers::Offset<BatchMatMulOptions> Finish()
7896   {
7897     const auto end = fbb_.EndTable(start_);
7898     auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
7899     return o;
7900   }
7901 };
7902
7903 inline flatbuffers::Offset<BatchMatMulOptions>
7904 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, bool adjoint_lhs = false,
7905                          bool adjoint_rhs = false)
7906 {
7907   BatchMatMulOptionsBuilder builder_(_fbb);
7908   builder_.add_adjoint_rhs(adjoint_rhs);
7909   builder_.add_adjoint_lhs(adjoint_lhs);
7910   return builder_.Finish();
7911 }
7912
7913 struct BCQGatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7914 {
7915   typedef BCQGatherOptionsBuilder Builder;
7916   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7917   {
7918     VT_INPUT_HIDDEN_SIZE = 4,
7919     VT_AXIS = 6
7920   };
7921   int32_t input_hidden_size() const { return GetField<int32_t>(VT_INPUT_HIDDEN_SIZE, 0); }
7922   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
7923   bool Verify(flatbuffers::Verifier &verifier) const
7924   {
7925     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_INPUT_HIDDEN_SIZE) &&
7926            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
7927   }
7928 };
7929
7930 struct BCQGatherOptionsBuilder
7931 {
7932   typedef BCQGatherOptions Table;
7933   flatbuffers::FlatBufferBuilder &fbb_;
7934   flatbuffers::uoffset_t start_;
7935   void add_input_hidden_size(int32_t input_hidden_size)
7936   {
7937     fbb_.AddElement<int32_t>(BCQGatherOptions::VT_INPUT_HIDDEN_SIZE, input_hidden_size, 0);
7938   }
7939   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(BCQGatherOptions::VT_AXIS, axis, 0); }
7940   explicit BCQGatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7941   {
7942     start_ = fbb_.StartTable();
7943   }
7944   BCQGatherOptionsBuilder &operator=(const BCQGatherOptionsBuilder &);
7945   flatbuffers::Offset<BCQGatherOptions> Finish()
7946   {
7947     const auto end = fbb_.EndTable(start_);
7948     auto o = flatbuffers::Offset<BCQGatherOptions>(end);
7949     return o;
7950   }
7951 };
7952
7953 inline flatbuffers::Offset<BCQGatherOptions>
7954 CreateBCQGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t input_hidden_size = 0,
7955                        int32_t axis = 0)
7956 {
7957   BCQGatherOptionsBuilder builder_(_fbb);
7958   builder_.add_axis(axis);
7959   builder_.add_input_hidden_size(input_hidden_size);
7960   return builder_.Finish();
7961 }
7962
7963 struct BCQFullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7964 {
7965   typedef BCQFullyConnectedOptionsBuilder Builder;
7966   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7967   {
7968     VT_WEIGHTS_HIDDEN_SIZE = 4,
7969     VT_FUSED_ACTIVATION_FUNCTION = 6
7970   };
7971   int32_t weights_hidden_size() const { return GetField<int32_t>(VT_WEIGHTS_HIDDEN_SIZE, 0); }
7972   circle::ActivationFunctionType fused_activation_function() const
7973   {
7974     return static_cast<circle::ActivationFunctionType>(
7975       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
7976   }
7977   bool Verify(flatbuffers::Verifier &verifier) const
7978   {
7979     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_WEIGHTS_HIDDEN_SIZE) &&
7980            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
7981   }
7982 };
7983
7984 struct BCQFullyConnectedOptionsBuilder
7985 {
7986   typedef BCQFullyConnectedOptions Table;
7987   flatbuffers::FlatBufferBuilder &fbb_;
7988   flatbuffers::uoffset_t start_;
7989   void add_weights_hidden_size(int32_t weights_hidden_size)
7990   {
7991     fbb_.AddElement<int32_t>(BCQFullyConnectedOptions::VT_WEIGHTS_HIDDEN_SIZE, weights_hidden_size,
7992                              0);
7993   }
7994   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
7995   {
7996     fbb_.AddElement<int8_t>(BCQFullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
7997                             static_cast<int8_t>(fused_activation_function), 0);
7998   }
7999   explicit BCQFullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8000   {
8001     start_ = fbb_.StartTable();
8002   }
8003   BCQFullyConnectedOptionsBuilder &operator=(const BCQFullyConnectedOptionsBuilder &);
8004   flatbuffers::Offset<BCQFullyConnectedOptions> Finish()
8005   {
8006     const auto end = fbb_.EndTable(start_);
8007     auto o = flatbuffers::Offset<BCQFullyConnectedOptions>(end);
8008     return o;
8009   }
8010 };
8011
8012 inline flatbuffers::Offset<BCQFullyConnectedOptions> CreateBCQFullyConnectedOptions(
8013   flatbuffers::FlatBufferBuilder &_fbb, int32_t weights_hidden_size = 0,
8014   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
8015 {
8016   BCQFullyConnectedOptionsBuilder builder_(_fbb);
8017   builder_.add_weights_hidden_size(weights_hidden_size);
8018   builder_.add_fused_activation_function(fused_activation_function);
8019   return builder_.Finish();
8020 }
8021
8022 struct InstanceNormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8023 {
8024   typedef InstanceNormOptionsBuilder Builder;
8025   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8026   {
8027     VT_EPSILON = 4,
8028     VT_FUSED_ACTIVATION_FUNCTION = 6
8029   };
8030   float epsilon() const { return GetField<float>(VT_EPSILON, 0.0f); }
8031   circle::ActivationFunctionType fused_activation_function() const
8032   {
8033     return static_cast<circle::ActivationFunctionType>(
8034       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
8035   }
8036   bool Verify(flatbuffers::Verifier &verifier) const
8037   {
8038     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_EPSILON) &&
8039            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
8040   }
8041 };
8042
8043 struct InstanceNormOptionsBuilder
8044 {
8045   typedef InstanceNormOptions Table;
8046   flatbuffers::FlatBufferBuilder &fbb_;
8047   flatbuffers::uoffset_t start_;
8048   void add_epsilon(float epsilon)
8049   {
8050     fbb_.AddElement<float>(InstanceNormOptions::VT_EPSILON, epsilon, 0.0f);
8051   }
8052   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
8053   {
8054     fbb_.AddElement<int8_t>(InstanceNormOptions::VT_FUSED_ACTIVATION_FUNCTION,
8055                             static_cast<int8_t>(fused_activation_function), 0);
8056   }
8057   explicit InstanceNormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8058   {
8059     start_ = fbb_.StartTable();
8060   }
8061   InstanceNormOptionsBuilder &operator=(const InstanceNormOptionsBuilder &);
8062   flatbuffers::Offset<InstanceNormOptions> Finish()
8063   {
8064     const auto end = fbb_.EndTable(start_);
8065     auto o = flatbuffers::Offset<InstanceNormOptions>(end);
8066     return o;
8067   }
8068 };
8069
8070 inline flatbuffers::Offset<InstanceNormOptions> CreateInstanceNormOptions(
8071   flatbuffers::FlatBufferBuilder &_fbb, float epsilon = 0.0f,
8072   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
8073 {
8074   InstanceNormOptionsBuilder builder_(_fbb);
8075   builder_.add_epsilon(epsilon);
8076   builder_.add_fused_activation_function(fused_activation_function);
8077   return builder_.Finish();
8078 }
8079
8080 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8081 {
8082   typedef OperatorCodeBuilder Builder;
8083   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8084   {
8085     VT_BUILTIN_CODE = 4,
8086     VT_CUSTOM_CODE = 6,
8087     VT_VERSION = 8
8088   };
8089   circle::BuiltinOperator builtin_code() const
8090   {
8091     return static_cast<circle::BuiltinOperator>(GetField<uint8_t>(VT_BUILTIN_CODE, 0));
8092   }
8093   const flatbuffers::String *custom_code() const
8094   {
8095     return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
8096   }
8097   int32_t version() const { return GetField<int32_t>(VT_VERSION, 1); }
8098   bool Verify(flatbuffers::Verifier &verifier) const
8099   {
8100     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_BUILTIN_CODE) &&
8101            VerifyOffset(verifier, VT_CUSTOM_CODE) && verifier.VerifyString(custom_code()) &&
8102            VerifyField<int32_t>(verifier, VT_VERSION) && verifier.EndTable();
8103   }
8104 };
8105
8106 struct OperatorCodeBuilder
8107 {
8108   typedef OperatorCode Table;
8109   flatbuffers::FlatBufferBuilder &fbb_;
8110   flatbuffers::uoffset_t start_;
8111   void add_builtin_code(circle::BuiltinOperator builtin_code)
8112   {
8113     fbb_.AddElement<uint8_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<uint8_t>(builtin_code), 0);
8114   }
8115   void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code)
8116   {
8117     fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
8118   }
8119   void add_version(int32_t version)
8120   {
8121     fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
8122   }
8123   explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8124   {
8125     start_ = fbb_.StartTable();
8126   }
8127   OperatorCodeBuilder &operator=(const OperatorCodeBuilder &);
8128   flatbuffers::Offset<OperatorCode> Finish()
8129   {
8130     const auto end = fbb_.EndTable(start_);
8131     auto o = flatbuffers::Offset<OperatorCode>(end);
8132     return o;
8133   }
8134 };
8135
8136 inline flatbuffers::Offset<OperatorCode>
8137 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb,
8138                    circle::BuiltinOperator builtin_code = circle::BuiltinOperator_ADD,
8139                    flatbuffers::Offset<flatbuffers::String> custom_code = 0, int32_t version = 1)
8140 {
8141   OperatorCodeBuilder builder_(_fbb);
8142   builder_.add_version(version);
8143   builder_.add_custom_code(custom_code);
8144   builder_.add_builtin_code(builtin_code);
8145   return builder_.Finish();
8146 }
8147
8148 inline flatbuffers::Offset<OperatorCode>
8149 CreateOperatorCodeDirect(flatbuffers::FlatBufferBuilder &_fbb,
8150                          circle::BuiltinOperator builtin_code = circle::BuiltinOperator_ADD,
8151                          const char *custom_code = nullptr, int32_t version = 1)
8152 {
8153   auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
8154   return circle::CreateOperatorCode(_fbb, builtin_code, custom_code__, version);
8155 }
8156
8157 struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8158 {
8159   typedef OperatorBuilder Builder;
8160   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8161   {
8162     VT_OPCODE_INDEX = 4,
8163     VT_INPUTS = 6,
8164     VT_OUTPUTS = 8,
8165     VT_BUILTIN_OPTIONS_TYPE = 10,
8166     VT_BUILTIN_OPTIONS = 12,
8167     VT_CUSTOM_OPTIONS = 14,
8168     VT_CUSTOM_OPTIONS_FORMAT = 16,
8169     VT_MUTATING_VARIABLE_INPUTS = 18,
8170     VT_INTERMEDIATES = 20
8171   };
8172   uint32_t opcode_index() const { return GetField<uint32_t>(VT_OPCODE_INDEX, 0); }
8173   const flatbuffers::Vector<int32_t> *inputs() const
8174   {
8175     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
8176   }
8177   const flatbuffers::Vector<int32_t> *outputs() const
8178   {
8179     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
8180   }
8181   circle::BuiltinOptions builtin_options_type() const
8182   {
8183     return static_cast<circle::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
8184   }
8185   const void *builtin_options() const { return GetPointer<const void *>(VT_BUILTIN_OPTIONS); }
8186   template <typename T> const T *builtin_options_as() const;
8187   const circle::Conv2DOptions *builtin_options_as_Conv2DOptions() const
8188   {
8189     return builtin_options_type() == circle::BuiltinOptions_Conv2DOptions
8190              ? static_cast<const circle::Conv2DOptions *>(builtin_options())
8191              : nullptr;
8192   }
8193   const circle::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const
8194   {
8195     return builtin_options_type() == circle::BuiltinOptions_DepthwiseConv2DOptions
8196              ? static_cast<const circle::DepthwiseConv2DOptions *>(builtin_options())
8197              : nullptr;
8198   }
8199   const circle::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const
8200   {
8201     return builtin_options_type() == circle::BuiltinOptions_ConcatEmbeddingsOptions
8202              ? static_cast<const circle::ConcatEmbeddingsOptions *>(builtin_options())
8203              : nullptr;
8204   }
8205   const circle::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const
8206   {
8207     return builtin_options_type() == circle::BuiltinOptions_LSHProjectionOptions
8208              ? static_cast<const circle::LSHProjectionOptions *>(builtin_options())
8209              : nullptr;
8210   }
8211   const circle::Pool2DOptions *builtin_options_as_Pool2DOptions() const
8212   {
8213     return builtin_options_type() == circle::BuiltinOptions_Pool2DOptions
8214              ? static_cast<const circle::Pool2DOptions *>(builtin_options())
8215              : nullptr;
8216   }
8217   const circle::SVDFOptions *builtin_options_as_SVDFOptions() const
8218   {
8219     return builtin_options_type() == circle::BuiltinOptions_SVDFOptions
8220              ? static_cast<const circle::SVDFOptions *>(builtin_options())
8221              : nullptr;
8222   }
8223   const circle::RNNOptions *builtin_options_as_RNNOptions() const
8224   {
8225     return builtin_options_type() == circle::BuiltinOptions_RNNOptions
8226              ? static_cast<const circle::RNNOptions *>(builtin_options())
8227              : nullptr;
8228   }
8229   const circle::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const
8230   {
8231     return builtin_options_type() == circle::BuiltinOptions_FullyConnectedOptions
8232              ? static_cast<const circle::FullyConnectedOptions *>(builtin_options())
8233              : nullptr;
8234   }
8235   const circle::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const
8236   {
8237     return builtin_options_type() == circle::BuiltinOptions_SoftmaxOptions
8238              ? static_cast<const circle::SoftmaxOptions *>(builtin_options())
8239              : nullptr;
8240   }
8241   const circle::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const
8242   {
8243     return builtin_options_type() == circle::BuiltinOptions_ConcatenationOptions
8244              ? static_cast<const circle::ConcatenationOptions *>(builtin_options())
8245              : nullptr;
8246   }
8247   const circle::AddOptions *builtin_options_as_AddOptions() const
8248   {
8249     return builtin_options_type() == circle::BuiltinOptions_AddOptions
8250              ? static_cast<const circle::AddOptions *>(builtin_options())
8251              : nullptr;
8252   }
8253   const circle::L2NormOptions *builtin_options_as_L2NormOptions() const
8254   {
8255     return builtin_options_type() == circle::BuiltinOptions_L2NormOptions
8256              ? static_cast<const circle::L2NormOptions *>(builtin_options())
8257              : nullptr;
8258   }
8259   const circle::LocalResponseNormalizationOptions *
8260   builtin_options_as_LocalResponseNormalizationOptions() const
8261   {
8262     return builtin_options_type() == circle::BuiltinOptions_LocalResponseNormalizationOptions
8263              ? static_cast<const circle::LocalResponseNormalizationOptions *>(builtin_options())
8264              : nullptr;
8265   }
8266   const circle::LSTMOptions *builtin_options_as_LSTMOptions() const
8267   {
8268     return builtin_options_type() == circle::BuiltinOptions_LSTMOptions
8269              ? static_cast<const circle::LSTMOptions *>(builtin_options())
8270              : nullptr;
8271   }
8272   const circle::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const
8273   {
8274     return builtin_options_type() == circle::BuiltinOptions_ResizeBilinearOptions
8275              ? static_cast<const circle::ResizeBilinearOptions *>(builtin_options())
8276              : nullptr;
8277   }
8278   const circle::CallOptions *builtin_options_as_CallOptions() const
8279   {
8280     return builtin_options_type() == circle::BuiltinOptions_CallOptions
8281              ? static_cast<const circle::CallOptions *>(builtin_options())
8282              : nullptr;
8283   }
8284   const circle::ReshapeOptions *builtin_options_as_ReshapeOptions() const
8285   {
8286     return builtin_options_type() == circle::BuiltinOptions_ReshapeOptions
8287              ? static_cast<const circle::ReshapeOptions *>(builtin_options())
8288              : nullptr;
8289   }
8290   const circle::SkipGramOptions *builtin_options_as_SkipGramOptions() const
8291   {
8292     return builtin_options_type() == circle::BuiltinOptions_SkipGramOptions
8293              ? static_cast<const circle::SkipGramOptions *>(builtin_options())
8294              : nullptr;
8295   }
8296   const circle::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const
8297   {
8298     return builtin_options_type() == circle::BuiltinOptions_SpaceToDepthOptions
8299              ? static_cast<const circle::SpaceToDepthOptions *>(builtin_options())
8300              : nullptr;
8301   }
8302   const circle::EmbeddingLookupSparseOptions *
8303   builtin_options_as_EmbeddingLookupSparseOptions() const
8304   {
8305     return builtin_options_type() == circle::BuiltinOptions_EmbeddingLookupSparseOptions
8306              ? static_cast<const circle::EmbeddingLookupSparseOptions *>(builtin_options())
8307              : nullptr;
8308   }
8309   const circle::MulOptions *builtin_options_as_MulOptions() const
8310   {
8311     return builtin_options_type() == circle::BuiltinOptions_MulOptions
8312              ? static_cast<const circle::MulOptions *>(builtin_options())
8313              : nullptr;
8314   }
8315   const circle::PadOptions *builtin_options_as_PadOptions() const
8316   {
8317     return builtin_options_type() == circle::BuiltinOptions_PadOptions
8318              ? static_cast<const circle::PadOptions *>(builtin_options())
8319              : nullptr;
8320   }
8321   const circle::GatherOptions *builtin_options_as_GatherOptions() const
8322   {
8323     return builtin_options_type() == circle::BuiltinOptions_GatherOptions
8324              ? static_cast<const circle::GatherOptions *>(builtin_options())
8325              : nullptr;
8326   }
8327   const circle::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const
8328   {
8329     return builtin_options_type() == circle::BuiltinOptions_BatchToSpaceNDOptions
8330              ? static_cast<const circle::BatchToSpaceNDOptions *>(builtin_options())
8331              : nullptr;
8332   }
8333   const circle::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const
8334   {
8335     return builtin_options_type() == circle::BuiltinOptions_SpaceToBatchNDOptions
8336              ? static_cast<const circle::SpaceToBatchNDOptions *>(builtin_options())
8337              : nullptr;
8338   }
8339   const circle::TransposeOptions *builtin_options_as_TransposeOptions() const
8340   {
8341     return builtin_options_type() == circle::BuiltinOptions_TransposeOptions
8342              ? static_cast<const circle::TransposeOptions *>(builtin_options())
8343              : nullptr;
8344   }
8345   const circle::ReducerOptions *builtin_options_as_ReducerOptions() const
8346   {
8347     return builtin_options_type() == circle::BuiltinOptions_ReducerOptions
8348              ? static_cast<const circle::ReducerOptions *>(builtin_options())
8349              : nullptr;
8350   }
8351   const circle::SubOptions *builtin_options_as_SubOptions() const
8352   {
8353     return builtin_options_type() == circle::BuiltinOptions_SubOptions
8354              ? static_cast<const circle::SubOptions *>(builtin_options())
8355              : nullptr;
8356   }
8357   const circle::DivOptions *builtin_options_as_DivOptions() const
8358   {
8359     return builtin_options_type() == circle::BuiltinOptions_DivOptions
8360              ? static_cast<const circle::DivOptions *>(builtin_options())
8361              : nullptr;
8362   }
8363   const circle::SqueezeOptions *builtin_options_as_SqueezeOptions() const
8364   {
8365     return builtin_options_type() == circle::BuiltinOptions_SqueezeOptions
8366              ? static_cast<const circle::SqueezeOptions *>(builtin_options())
8367              : nullptr;
8368   }
8369   const circle::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const
8370   {
8371     return builtin_options_type() == circle::BuiltinOptions_SequenceRNNOptions
8372              ? static_cast<const circle::SequenceRNNOptions *>(builtin_options())
8373              : nullptr;
8374   }
8375   const circle::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const
8376   {
8377     return builtin_options_type() == circle::BuiltinOptions_StridedSliceOptions
8378              ? static_cast<const circle::StridedSliceOptions *>(builtin_options())
8379              : nullptr;
8380   }
8381   const circle::ExpOptions *builtin_options_as_ExpOptions() const
8382   {
8383     return builtin_options_type() == circle::BuiltinOptions_ExpOptions
8384              ? static_cast<const circle::ExpOptions *>(builtin_options())
8385              : nullptr;
8386   }
8387   const circle::TopKV2Options *builtin_options_as_TopKV2Options() const
8388   {
8389     return builtin_options_type() == circle::BuiltinOptions_TopKV2Options
8390              ? static_cast<const circle::TopKV2Options *>(builtin_options())
8391              : nullptr;
8392   }
8393   const circle::SplitOptions *builtin_options_as_SplitOptions() const
8394   {
8395     return builtin_options_type() == circle::BuiltinOptions_SplitOptions
8396              ? static_cast<const circle::SplitOptions *>(builtin_options())
8397              : nullptr;
8398   }
8399   const circle::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const
8400   {
8401     return builtin_options_type() == circle::BuiltinOptions_LogSoftmaxOptions
8402              ? static_cast<const circle::LogSoftmaxOptions *>(builtin_options())
8403              : nullptr;
8404   }
8405   const circle::CastOptions *builtin_options_as_CastOptions() const
8406   {
8407     return builtin_options_type() == circle::BuiltinOptions_CastOptions
8408              ? static_cast<const circle::CastOptions *>(builtin_options())
8409              : nullptr;
8410   }
8411   const circle::DequantizeOptions *builtin_options_as_DequantizeOptions() const
8412   {
8413     return builtin_options_type() == circle::BuiltinOptions_DequantizeOptions
8414              ? static_cast<const circle::DequantizeOptions *>(builtin_options())
8415              : nullptr;
8416   }
8417   const circle::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const
8418   {
8419     return builtin_options_type() == circle::BuiltinOptions_MaximumMinimumOptions
8420              ? static_cast<const circle::MaximumMinimumOptions *>(builtin_options())
8421              : nullptr;
8422   }
8423   const circle::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const
8424   {
8425     return builtin_options_type() == circle::BuiltinOptions_ArgMaxOptions
8426              ? static_cast<const circle::ArgMaxOptions *>(builtin_options())
8427              : nullptr;
8428   }
8429   const circle::LessOptions *builtin_options_as_LessOptions() const
8430   {
8431     return builtin_options_type() == circle::BuiltinOptions_LessOptions
8432              ? static_cast<const circle::LessOptions *>(builtin_options())
8433              : nullptr;
8434   }
8435   const circle::NegOptions *builtin_options_as_NegOptions() const
8436   {
8437     return builtin_options_type() == circle::BuiltinOptions_NegOptions
8438              ? static_cast<const circle::NegOptions *>(builtin_options())
8439              : nullptr;
8440   }
8441   const circle::PadV2Options *builtin_options_as_PadV2Options() const
8442   {
8443     return builtin_options_type() == circle::BuiltinOptions_PadV2Options
8444              ? static_cast<const circle::PadV2Options *>(builtin_options())
8445              : nullptr;
8446   }
8447   const circle::GreaterOptions *builtin_options_as_GreaterOptions() const
8448   {
8449     return builtin_options_type() == circle::BuiltinOptions_GreaterOptions
8450              ? static_cast<const circle::GreaterOptions *>(builtin_options())
8451              : nullptr;
8452   }
8453   const circle::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const
8454   {
8455     return builtin_options_type() == circle::BuiltinOptions_GreaterEqualOptions
8456              ? static_cast<const circle::GreaterEqualOptions *>(builtin_options())
8457              : nullptr;
8458   }
8459   const circle::LessEqualOptions *builtin_options_as_LessEqualOptions() const
8460   {
8461     return builtin_options_type() == circle::BuiltinOptions_LessEqualOptions
8462              ? static_cast<const circle::LessEqualOptions *>(builtin_options())
8463              : nullptr;
8464   }
8465   const circle::SelectOptions *builtin_options_as_SelectOptions() const
8466   {
8467     return builtin_options_type() == circle::BuiltinOptions_SelectOptions
8468              ? static_cast<const circle::SelectOptions *>(builtin_options())
8469              : nullptr;
8470   }
8471   const circle::SliceOptions *builtin_options_as_SliceOptions() const
8472   {
8473     return builtin_options_type() == circle::BuiltinOptions_SliceOptions
8474              ? static_cast<const circle::SliceOptions *>(builtin_options())
8475              : nullptr;
8476   }
8477   const circle::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const
8478   {
8479     return builtin_options_type() == circle::BuiltinOptions_TransposeConvOptions
8480              ? static_cast<const circle::TransposeConvOptions *>(builtin_options())
8481              : nullptr;
8482   }
8483   const circle::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const
8484   {
8485     return builtin_options_type() == circle::BuiltinOptions_SparseToDenseOptions
8486              ? static_cast<const circle::SparseToDenseOptions *>(builtin_options())
8487              : nullptr;
8488   }
8489   const circle::TileOptions *builtin_options_as_TileOptions() const
8490   {
8491     return builtin_options_type() == circle::BuiltinOptions_TileOptions
8492              ? static_cast<const circle::TileOptions *>(builtin_options())
8493              : nullptr;
8494   }
8495   const circle::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const
8496   {
8497     return builtin_options_type() == circle::BuiltinOptions_ExpandDimsOptions
8498              ? static_cast<const circle::ExpandDimsOptions *>(builtin_options())
8499              : nullptr;
8500   }
8501   const circle::EqualOptions *builtin_options_as_EqualOptions() const
8502   {
8503     return builtin_options_type() == circle::BuiltinOptions_EqualOptions
8504              ? static_cast<const circle::EqualOptions *>(builtin_options())
8505              : nullptr;
8506   }
8507   const circle::NotEqualOptions *builtin_options_as_NotEqualOptions() const
8508   {
8509     return builtin_options_type() == circle::BuiltinOptions_NotEqualOptions
8510              ? static_cast<const circle::NotEqualOptions *>(builtin_options())
8511              : nullptr;
8512   }
8513   const circle::ShapeOptions *builtin_options_as_ShapeOptions() const
8514   {
8515     return builtin_options_type() == circle::BuiltinOptions_ShapeOptions
8516              ? static_cast<const circle::ShapeOptions *>(builtin_options())
8517              : nullptr;
8518   }
8519   const circle::PowOptions *builtin_options_as_PowOptions() const
8520   {
8521     return builtin_options_type() == circle::BuiltinOptions_PowOptions
8522              ? static_cast<const circle::PowOptions *>(builtin_options())
8523              : nullptr;
8524   }
8525   const circle::ArgMinOptions *builtin_options_as_ArgMinOptions() const
8526   {
8527     return builtin_options_type() == circle::BuiltinOptions_ArgMinOptions
8528              ? static_cast<const circle::ArgMinOptions *>(builtin_options())
8529              : nullptr;
8530   }
8531   const circle::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const
8532   {
8533     return builtin_options_type() == circle::BuiltinOptions_FakeQuantOptions
8534              ? static_cast<const circle::FakeQuantOptions *>(builtin_options())
8535              : nullptr;
8536   }
8537   const circle::PackOptions *builtin_options_as_PackOptions() const
8538   {
8539     return builtin_options_type() == circle::BuiltinOptions_PackOptions
8540              ? static_cast<const circle::PackOptions *>(builtin_options())
8541              : nullptr;
8542   }
8543   const circle::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const
8544   {
8545     return builtin_options_type() == circle::BuiltinOptions_LogicalOrOptions
8546              ? static_cast<const circle::LogicalOrOptions *>(builtin_options())
8547              : nullptr;
8548   }
8549   const circle::OneHotOptions *builtin_options_as_OneHotOptions() const
8550   {
8551     return builtin_options_type() == circle::BuiltinOptions_OneHotOptions
8552              ? static_cast<const circle::OneHotOptions *>(builtin_options())
8553              : nullptr;
8554   }
8555   const circle::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const
8556   {
8557     return builtin_options_type() == circle::BuiltinOptions_LogicalAndOptions
8558              ? static_cast<const circle::LogicalAndOptions *>(builtin_options())
8559              : nullptr;
8560   }
8561   const circle::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const
8562   {
8563     return builtin_options_type() == circle::BuiltinOptions_LogicalNotOptions
8564              ? static_cast<const circle::LogicalNotOptions *>(builtin_options())
8565              : nullptr;
8566   }
8567   const circle::UnpackOptions *builtin_options_as_UnpackOptions() const
8568   {
8569     return builtin_options_type() == circle::BuiltinOptions_UnpackOptions
8570              ? static_cast<const circle::UnpackOptions *>(builtin_options())
8571              : nullptr;
8572   }
8573   const circle::FloorDivOptions *builtin_options_as_FloorDivOptions() const
8574   {
8575     return builtin_options_type() == circle::BuiltinOptions_FloorDivOptions
8576              ? static_cast<const circle::FloorDivOptions *>(builtin_options())
8577              : nullptr;
8578   }
8579   const circle::SquareOptions *builtin_options_as_SquareOptions() const
8580   {
8581     return builtin_options_type() == circle::BuiltinOptions_SquareOptions
8582              ? static_cast<const circle::SquareOptions *>(builtin_options())
8583              : nullptr;
8584   }
8585   const circle::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const
8586   {
8587     return builtin_options_type() == circle::BuiltinOptions_ZerosLikeOptions
8588              ? static_cast<const circle::ZerosLikeOptions *>(builtin_options())
8589              : nullptr;
8590   }
8591   const circle::FillOptions *builtin_options_as_FillOptions() const
8592   {
8593     return builtin_options_type() == circle::BuiltinOptions_FillOptions
8594              ? static_cast<const circle::FillOptions *>(builtin_options())
8595              : nullptr;
8596   }
8597   const circle::BidirectionalSequenceLSTMOptions *
8598   builtin_options_as_BidirectionalSequenceLSTMOptions() const
8599   {
8600     return builtin_options_type() == circle::BuiltinOptions_BidirectionalSequenceLSTMOptions
8601              ? static_cast<const circle::BidirectionalSequenceLSTMOptions *>(builtin_options())
8602              : nullptr;
8603   }
8604   const circle::BidirectionalSequenceRNNOptions *
8605   builtin_options_as_BidirectionalSequenceRNNOptions() const
8606   {
8607     return builtin_options_type() == circle::BuiltinOptions_BidirectionalSequenceRNNOptions
8608              ? static_cast<const circle::BidirectionalSequenceRNNOptions *>(builtin_options())
8609              : nullptr;
8610   }
8611   const circle::UnidirectionalSequenceLSTMOptions *
8612   builtin_options_as_UnidirectionalSequenceLSTMOptions() const
8613   {
8614     return builtin_options_type() == circle::BuiltinOptions_UnidirectionalSequenceLSTMOptions
8615              ? static_cast<const circle::UnidirectionalSequenceLSTMOptions *>(builtin_options())
8616              : nullptr;
8617   }
8618   const circle::FloorModOptions *builtin_options_as_FloorModOptions() const
8619   {
8620     return builtin_options_type() == circle::BuiltinOptions_FloorModOptions
8621              ? static_cast<const circle::FloorModOptions *>(builtin_options())
8622              : nullptr;
8623   }
8624   const circle::RangeOptions *builtin_options_as_RangeOptions() const
8625   {
8626     return builtin_options_type() == circle::BuiltinOptions_RangeOptions
8627              ? static_cast<const circle::RangeOptions *>(builtin_options())
8628              : nullptr;
8629   }
8630   const circle::ResizeNearestNeighborOptions *
8631   builtin_options_as_ResizeNearestNeighborOptions() const
8632   {
8633     return builtin_options_type() == circle::BuiltinOptions_ResizeNearestNeighborOptions
8634              ? static_cast<const circle::ResizeNearestNeighborOptions *>(builtin_options())
8635              : nullptr;
8636   }
8637   const circle::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const
8638   {
8639     return builtin_options_type() == circle::BuiltinOptions_LeakyReluOptions
8640              ? static_cast<const circle::LeakyReluOptions *>(builtin_options())
8641              : nullptr;
8642   }
8643   const circle::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const
8644   {
8645     return builtin_options_type() == circle::BuiltinOptions_SquaredDifferenceOptions
8646              ? static_cast<const circle::SquaredDifferenceOptions *>(builtin_options())
8647              : nullptr;
8648   }
8649   const circle::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const
8650   {
8651     return builtin_options_type() == circle::BuiltinOptions_MirrorPadOptions
8652              ? static_cast<const circle::MirrorPadOptions *>(builtin_options())
8653              : nullptr;
8654   }
8655   const circle::AbsOptions *builtin_options_as_AbsOptions() const
8656   {
8657     return builtin_options_type() == circle::BuiltinOptions_AbsOptions
8658              ? static_cast<const circle::AbsOptions *>(builtin_options())
8659              : nullptr;
8660   }
8661   const circle::SplitVOptions *builtin_options_as_SplitVOptions() const
8662   {
8663     return builtin_options_type() == circle::BuiltinOptions_SplitVOptions
8664              ? static_cast<const circle::SplitVOptions *>(builtin_options())
8665              : nullptr;
8666   }
8667   const circle::UniqueOptions *builtin_options_as_UniqueOptions() const
8668   {
8669     return builtin_options_type() == circle::BuiltinOptions_UniqueOptions
8670              ? static_cast<const circle::UniqueOptions *>(builtin_options())
8671              : nullptr;
8672   }
8673   const circle::ReverseV2Options *builtin_options_as_ReverseV2Options() const
8674   {
8675     return builtin_options_type() == circle::BuiltinOptions_ReverseV2Options
8676              ? static_cast<const circle::ReverseV2Options *>(builtin_options())
8677              : nullptr;
8678   }
8679   const circle::AddNOptions *builtin_options_as_AddNOptions() const
8680   {
8681     return builtin_options_type() == circle::BuiltinOptions_AddNOptions
8682              ? static_cast<const circle::AddNOptions *>(builtin_options())
8683              : nullptr;
8684   }
8685   const circle::GatherNdOptions *builtin_options_as_GatherNdOptions() const
8686   {
8687     return builtin_options_type() == circle::BuiltinOptions_GatherNdOptions
8688              ? static_cast<const circle::GatherNdOptions *>(builtin_options())
8689              : nullptr;
8690   }
8691   const circle::CosOptions *builtin_options_as_CosOptions() const
8692   {
8693     return builtin_options_type() == circle::BuiltinOptions_CosOptions
8694              ? static_cast<const circle::CosOptions *>(builtin_options())
8695              : nullptr;
8696   }
8697   const circle::WhereOptions *builtin_options_as_WhereOptions() const
8698   {
8699     return builtin_options_type() == circle::BuiltinOptions_WhereOptions
8700              ? static_cast<const circle::WhereOptions *>(builtin_options())
8701              : nullptr;
8702   }
8703   const circle::RankOptions *builtin_options_as_RankOptions() const
8704   {
8705     return builtin_options_type() == circle::BuiltinOptions_RankOptions
8706              ? static_cast<const circle::RankOptions *>(builtin_options())
8707              : nullptr;
8708   }
8709   const circle::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const
8710   {
8711     return builtin_options_type() == circle::BuiltinOptions_ReverseSequenceOptions
8712              ? static_cast<const circle::ReverseSequenceOptions *>(builtin_options())
8713              : nullptr;
8714   }
8715   const circle::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const
8716   {
8717     return builtin_options_type() == circle::BuiltinOptions_MatrixDiagOptions
8718              ? static_cast<const circle::MatrixDiagOptions *>(builtin_options())
8719              : nullptr;
8720   }
8721   const circle::QuantizeOptions *builtin_options_as_QuantizeOptions() const
8722   {
8723     return builtin_options_type() == circle::BuiltinOptions_QuantizeOptions
8724              ? static_cast<const circle::QuantizeOptions *>(builtin_options())
8725              : nullptr;
8726   }
8727   const circle::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const
8728   {
8729     return builtin_options_type() == circle::BuiltinOptions_MatrixSetDiagOptions
8730              ? static_cast<const circle::MatrixSetDiagOptions *>(builtin_options())
8731              : nullptr;
8732   }
8733   const circle::HardSwishOptions *builtin_options_as_HardSwishOptions() const
8734   {
8735     return builtin_options_type() == circle::BuiltinOptions_HardSwishOptions
8736              ? static_cast<const circle::HardSwishOptions *>(builtin_options())
8737              : nullptr;
8738   }
8739   const circle::IfOptions *builtin_options_as_IfOptions() const
8740   {
8741     return builtin_options_type() == circle::BuiltinOptions_IfOptions
8742              ? static_cast<const circle::IfOptions *>(builtin_options())
8743              : nullptr;
8744   }
8745   const circle::WhileOptions *builtin_options_as_WhileOptions() const
8746   {
8747     return builtin_options_type() == circle::BuiltinOptions_WhileOptions
8748              ? static_cast<const circle::WhileOptions *>(builtin_options())
8749              : nullptr;
8750   }
8751   const circle::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const
8752   {
8753     return builtin_options_type() == circle::BuiltinOptions_DepthToSpaceOptions
8754              ? static_cast<const circle::DepthToSpaceOptions *>(builtin_options())
8755              : nullptr;
8756   }
8757   const circle::NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const
8758   {
8759     return builtin_options_type() == circle::BuiltinOptions_NonMaxSuppressionV4Options
8760              ? static_cast<const circle::NonMaxSuppressionV4Options *>(builtin_options())
8761              : nullptr;
8762   }
8763   const circle::NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const
8764   {
8765     return builtin_options_type() == circle::BuiltinOptions_NonMaxSuppressionV5Options
8766              ? static_cast<const circle::NonMaxSuppressionV5Options *>(builtin_options())
8767              : nullptr;
8768   }
8769   const circle::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const
8770   {
8771     return builtin_options_type() == circle::BuiltinOptions_ScatterNdOptions
8772              ? static_cast<const circle::ScatterNdOptions *>(builtin_options())
8773              : nullptr;
8774   }
8775   const circle::SelectV2Options *builtin_options_as_SelectV2Options() const
8776   {
8777     return builtin_options_type() == circle::BuiltinOptions_SelectV2Options
8778              ? static_cast<const circle::SelectV2Options *>(builtin_options())
8779              : nullptr;
8780   }
8781   const circle::DensifyOptions *builtin_options_as_DensifyOptions() const
8782   {
8783     return builtin_options_type() == circle::BuiltinOptions_DensifyOptions
8784              ? static_cast<const circle::DensifyOptions *>(builtin_options())
8785              : nullptr;
8786   }
8787   const circle::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const
8788   {
8789     return builtin_options_type() == circle::BuiltinOptions_SegmentSumOptions
8790              ? static_cast<const circle::SegmentSumOptions *>(builtin_options())
8791              : nullptr;
8792   }
8793   const circle::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const
8794   {
8795     return builtin_options_type() == circle::BuiltinOptions_BatchMatMulOptions
8796              ? static_cast<const circle::BatchMatMulOptions *>(builtin_options())
8797              : nullptr;
8798   }
8799   const circle::BCQGatherOptions *builtin_options_as_BCQGatherOptions() const
8800   {
8801     return builtin_options_type() == circle::BuiltinOptions_BCQGatherOptions
8802              ? static_cast<const circle::BCQGatherOptions *>(builtin_options())
8803              : nullptr;
8804   }
8805   const circle::BCQFullyConnectedOptions *builtin_options_as_BCQFullyConnectedOptions() const
8806   {
8807     return builtin_options_type() == circle::BuiltinOptions_BCQFullyConnectedOptions
8808              ? static_cast<const circle::BCQFullyConnectedOptions *>(builtin_options())
8809              : nullptr;
8810   }
8811   const circle::InstanceNormOptions *builtin_options_as_InstanceNormOptions() const
8812   {
8813     return builtin_options_type() == circle::BuiltinOptions_InstanceNormOptions
8814              ? static_cast<const circle::InstanceNormOptions *>(builtin_options())
8815              : nullptr;
8816   }
8817   const flatbuffers::Vector<uint8_t> *custom_options() const
8818   {
8819     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
8820   }
8821   circle::CustomOptionsFormat custom_options_format() const
8822   {
8823     return static_cast<circle::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
8824   }
8825   const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const
8826   {
8827     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
8828   }
8829   const flatbuffers::Vector<int32_t> *intermediates() const
8830   {
8831     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
8832   }
8833   bool Verify(flatbuffers::Verifier &verifier) const
8834   {
8835     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
8836            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
8837            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
8838            VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
8839            VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
8840            VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
8841            VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && verifier.VerifyVector(custom_options()) &&
8842            VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
8843            VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
8844            verifier.VerifyVector(mutating_variable_inputs()) &&
8845            VerifyOffset(verifier, VT_INTERMEDIATES) && verifier.VerifyVector(intermediates()) &&
8846            verifier.EndTable();
8847   }
8848 };
8849
8850 template <>
8851 inline const circle::Conv2DOptions *Operator::builtin_options_as<circle::Conv2DOptions>() const
8852 {
8853   return builtin_options_as_Conv2DOptions();
8854 }
8855
8856 template <>
8857 inline const circle::DepthwiseConv2DOptions *
8858 Operator::builtin_options_as<circle::DepthwiseConv2DOptions>() const
8859 {
8860   return builtin_options_as_DepthwiseConv2DOptions();
8861 }
8862
8863 template <>
8864 inline const circle::ConcatEmbeddingsOptions *
8865 Operator::builtin_options_as<circle::ConcatEmbeddingsOptions>() const
8866 {
8867   return builtin_options_as_ConcatEmbeddingsOptions();
8868 }
8869
8870 template <>
8871 inline const circle::LSHProjectionOptions *
8872 Operator::builtin_options_as<circle::LSHProjectionOptions>() const
8873 {
8874   return builtin_options_as_LSHProjectionOptions();
8875 }
8876
8877 template <>
8878 inline const circle::Pool2DOptions *Operator::builtin_options_as<circle::Pool2DOptions>() const
8879 {
8880   return builtin_options_as_Pool2DOptions();
8881 }
8882
8883 template <>
8884 inline const circle::SVDFOptions *Operator::builtin_options_as<circle::SVDFOptions>() const
8885 {
8886   return builtin_options_as_SVDFOptions();
8887 }
8888
8889 template <>
8890 inline const circle::RNNOptions *Operator::builtin_options_as<circle::RNNOptions>() const
8891 {
8892   return builtin_options_as_RNNOptions();
8893 }
8894
8895 template <>
8896 inline const circle::FullyConnectedOptions *
8897 Operator::builtin_options_as<circle::FullyConnectedOptions>() const
8898 {
8899   return builtin_options_as_FullyConnectedOptions();
8900 }
8901
8902 template <>
8903 inline const circle::SoftmaxOptions *Operator::builtin_options_as<circle::SoftmaxOptions>() const
8904 {
8905   return builtin_options_as_SoftmaxOptions();
8906 }
8907
8908 template <>
8909 inline const circle::ConcatenationOptions *
8910 Operator::builtin_options_as<circle::ConcatenationOptions>() const
8911 {
8912   return builtin_options_as_ConcatenationOptions();
8913 }
8914
8915 template <>
8916 inline const circle::AddOptions *Operator::builtin_options_as<circle::AddOptions>() const
8917 {
8918   return builtin_options_as_AddOptions();
8919 }
8920
8921 template <>
8922 inline const circle::L2NormOptions *Operator::builtin_options_as<circle::L2NormOptions>() const
8923 {
8924   return builtin_options_as_L2NormOptions();
8925 }
8926
8927 template <>
8928 inline const circle::LocalResponseNormalizationOptions *
8929 Operator::builtin_options_as<circle::LocalResponseNormalizationOptions>() const
8930 {
8931   return builtin_options_as_LocalResponseNormalizationOptions();
8932 }
8933
8934 template <>
8935 inline const circle::LSTMOptions *Operator::builtin_options_as<circle::LSTMOptions>() const
8936 {
8937   return builtin_options_as_LSTMOptions();
8938 }
8939
8940 template <>
8941 inline const circle::ResizeBilinearOptions *
8942 Operator::builtin_options_as<circle::ResizeBilinearOptions>() const
8943 {
8944   return builtin_options_as_ResizeBilinearOptions();
8945 }
8946
8947 template <>
8948 inline const circle::CallOptions *Operator::builtin_options_as<circle::CallOptions>() const
8949 {
8950   return builtin_options_as_CallOptions();
8951 }
8952
8953 template <>
8954 inline const circle::ReshapeOptions *Operator::builtin_options_as<circle::ReshapeOptions>() const
8955 {
8956   return builtin_options_as_ReshapeOptions();
8957 }
8958
8959 template <>
8960 inline const circle::SkipGramOptions *Operator::builtin_options_as<circle::SkipGramOptions>() const
8961 {
8962   return builtin_options_as_SkipGramOptions();
8963 }
8964
8965 template <>
8966 inline const circle::SpaceToDepthOptions *
8967 Operator::builtin_options_as<circle::SpaceToDepthOptions>() const
8968 {
8969   return builtin_options_as_SpaceToDepthOptions();
8970 }
8971
8972 template <>
8973 inline const circle::EmbeddingLookupSparseOptions *
8974 Operator::builtin_options_as<circle::EmbeddingLookupSparseOptions>() const
8975 {
8976   return builtin_options_as_EmbeddingLookupSparseOptions();
8977 }
8978
8979 template <>
8980 inline const circle::MulOptions *Operator::builtin_options_as<circle::MulOptions>() const
8981 {
8982   return builtin_options_as_MulOptions();
8983 }
8984
8985 template <>
8986 inline const circle::PadOptions *Operator::builtin_options_as<circle::PadOptions>() const
8987 {
8988   return builtin_options_as_PadOptions();
8989 }
8990
8991 template <>
8992 inline const circle::GatherOptions *Operator::builtin_options_as<circle::GatherOptions>() const
8993 {
8994   return builtin_options_as_GatherOptions();
8995 }
8996
8997 template <>
8998 inline const circle::BatchToSpaceNDOptions *
8999 Operator::builtin_options_as<circle::BatchToSpaceNDOptions>() const
9000 {
9001   return builtin_options_as_BatchToSpaceNDOptions();
9002 }
9003
9004 template <>
9005 inline const circle::SpaceToBatchNDOptions *
9006 Operator::builtin_options_as<circle::SpaceToBatchNDOptions>() const
9007 {
9008   return builtin_options_as_SpaceToBatchNDOptions();
9009 }
9010
9011 template <>
9012 inline const circle::TransposeOptions *
9013 Operator::builtin_options_as<circle::TransposeOptions>() const
9014 {
9015   return builtin_options_as_TransposeOptions();
9016 }
9017
9018 template <>
9019 inline const circle::ReducerOptions *Operator::builtin_options_as<circle::ReducerOptions>() const
9020 {
9021   return builtin_options_as_ReducerOptions();
9022 }
9023
9024 template <>
9025 inline const circle::SubOptions *Operator::builtin_options_as<circle::SubOptions>() const
9026 {
9027   return builtin_options_as_SubOptions();
9028 }
9029
9030 template <>
9031 inline const circle::DivOptions *Operator::builtin_options_as<circle::DivOptions>() const
9032 {
9033   return builtin_options_as_DivOptions();
9034 }
9035
9036 template <>
9037 inline const circle::SqueezeOptions *Operator::builtin_options_as<circle::SqueezeOptions>() const
9038 {
9039   return builtin_options_as_SqueezeOptions();
9040 }
9041
9042 template <>
9043 inline const circle::SequenceRNNOptions *
9044 Operator::builtin_options_as<circle::SequenceRNNOptions>() const
9045 {
9046   return builtin_options_as_SequenceRNNOptions();
9047 }
9048
9049 template <>
9050 inline const circle::StridedSliceOptions *
9051 Operator::builtin_options_as<circle::StridedSliceOptions>() const
9052 {
9053   return builtin_options_as_StridedSliceOptions();
9054 }
9055
9056 template <>
9057 inline const circle::ExpOptions *Operator::builtin_options_as<circle::ExpOptions>() const
9058 {
9059   return builtin_options_as_ExpOptions();
9060 }
9061
9062 template <>
9063 inline const circle::TopKV2Options *Operator::builtin_options_as<circle::TopKV2Options>() const
9064 {
9065   return builtin_options_as_TopKV2Options();
9066 }
9067
9068 template <>
9069 inline const circle::SplitOptions *Operator::builtin_options_as<circle::SplitOptions>() const
9070 {
9071   return builtin_options_as_SplitOptions();
9072 }
9073
9074 template <>
9075 inline const circle::LogSoftmaxOptions *
9076 Operator::builtin_options_as<circle::LogSoftmaxOptions>() const
9077 {
9078   return builtin_options_as_LogSoftmaxOptions();
9079 }
9080
9081 template <>
9082 inline const circle::CastOptions *Operator::builtin_options_as<circle::CastOptions>() const
9083 {
9084   return builtin_options_as_CastOptions();
9085 }
9086
9087 template <>
9088 inline const circle::DequantizeOptions *
9089 Operator::builtin_options_as<circle::DequantizeOptions>() const
9090 {
9091   return builtin_options_as_DequantizeOptions();
9092 }
9093
9094 template <>
9095 inline const circle::MaximumMinimumOptions *
9096 Operator::builtin_options_as<circle::MaximumMinimumOptions>() const
9097 {
9098   return builtin_options_as_MaximumMinimumOptions();
9099 }
9100
9101 template <>
9102 inline const circle::ArgMaxOptions *Operator::builtin_options_as<circle::ArgMaxOptions>() const
9103 {
9104   return builtin_options_as_ArgMaxOptions();
9105 }
9106
9107 template <>
9108 inline const circle::LessOptions *Operator::builtin_options_as<circle::LessOptions>() const
9109 {
9110   return builtin_options_as_LessOptions();
9111 }
9112
9113 template <>
9114 inline const circle::NegOptions *Operator::builtin_options_as<circle::NegOptions>() const
9115 {
9116   return builtin_options_as_NegOptions();
9117 }
9118
9119 template <>
9120 inline const circle::PadV2Options *Operator::builtin_options_as<circle::PadV2Options>() const
9121 {
9122   return builtin_options_as_PadV2Options();
9123 }
9124
9125 template <>
9126 inline const circle::GreaterOptions *Operator::builtin_options_as<circle::GreaterOptions>() const
9127 {
9128   return builtin_options_as_GreaterOptions();
9129 }
9130
9131 template <>
9132 inline const circle::GreaterEqualOptions *
9133 Operator::builtin_options_as<circle::GreaterEqualOptions>() const
9134 {
9135   return builtin_options_as_GreaterEqualOptions();
9136 }
9137
9138 template <>
9139 inline const circle::LessEqualOptions *
9140 Operator::builtin_options_as<circle::LessEqualOptions>() const
9141 {
9142   return builtin_options_as_LessEqualOptions();
9143 }
9144
9145 template <>
9146 inline const circle::SelectOptions *Operator::builtin_options_as<circle::SelectOptions>() const
9147 {
9148   return builtin_options_as_SelectOptions();
9149 }
9150
9151 template <>
9152 inline const circle::SliceOptions *Operator::builtin_options_as<circle::SliceOptions>() const
9153 {
9154   return builtin_options_as_SliceOptions();
9155 }
9156
9157 template <>
9158 inline const circle::TransposeConvOptions *
9159 Operator::builtin_options_as<circle::TransposeConvOptions>() const
9160 {
9161   return builtin_options_as_TransposeConvOptions();
9162 }
9163
9164 template <>
9165 inline const circle::SparseToDenseOptions *
9166 Operator::builtin_options_as<circle::SparseToDenseOptions>() const
9167 {
9168   return builtin_options_as_SparseToDenseOptions();
9169 }
9170
9171 template <>
9172 inline const circle::TileOptions *Operator::builtin_options_as<circle::TileOptions>() const
9173 {
9174   return builtin_options_as_TileOptions();
9175 }
9176
9177 template <>
9178 inline const circle::ExpandDimsOptions *
9179 Operator::builtin_options_as<circle::ExpandDimsOptions>() const
9180 {
9181   return builtin_options_as_ExpandDimsOptions();
9182 }
9183
9184 template <>
9185 inline const circle::EqualOptions *Operator::builtin_options_as<circle::EqualOptions>() const
9186 {
9187   return builtin_options_as_EqualOptions();
9188 }
9189
9190 template <>
9191 inline const circle::NotEqualOptions *Operator::builtin_options_as<circle::NotEqualOptions>() const
9192 {
9193   return builtin_options_as_NotEqualOptions();
9194 }
9195
9196 template <>
9197 inline const circle::ShapeOptions *Operator::builtin_options_as<circle::ShapeOptions>() const
9198 {
9199   return builtin_options_as_ShapeOptions();
9200 }
9201
9202 template <>
9203 inline const circle::PowOptions *Operator::builtin_options_as<circle::PowOptions>() const
9204 {
9205   return builtin_options_as_PowOptions();
9206 }
9207
9208 template <>
9209 inline const circle::ArgMinOptions *Operator::builtin_options_as<circle::ArgMinOptions>() const
9210 {
9211   return builtin_options_as_ArgMinOptions();
9212 }
9213
9214 template <>
9215 inline const circle::FakeQuantOptions *
9216 Operator::builtin_options_as<circle::FakeQuantOptions>() const
9217 {
9218   return builtin_options_as_FakeQuantOptions();
9219 }
9220
9221 template <>
9222 inline const circle::PackOptions *Operator::builtin_options_as<circle::PackOptions>() const
9223 {
9224   return builtin_options_as_PackOptions();
9225 }
9226
9227 template <>
9228 inline const circle::LogicalOrOptions *
9229 Operator::builtin_options_as<circle::LogicalOrOptions>() const
9230 {
9231   return builtin_options_as_LogicalOrOptions();
9232 }
9233
9234 template <>
9235 inline const circle::OneHotOptions *Operator::builtin_options_as<circle::OneHotOptions>() const
9236 {
9237   return builtin_options_as_OneHotOptions();
9238 }
9239
9240 template <>
9241 inline const circle::LogicalAndOptions *
9242 Operator::builtin_options_as<circle::LogicalAndOptions>() const
9243 {
9244   return builtin_options_as_LogicalAndOptions();
9245 }
9246
9247 template <>
9248 inline const circle::LogicalNotOptions *
9249 Operator::builtin_options_as<circle::LogicalNotOptions>() const
9250 {
9251   return builtin_options_as_LogicalNotOptions();
9252 }
9253
9254 template <>
9255 inline const circle::UnpackOptions *Operator::builtin_options_as<circle::UnpackOptions>() const
9256 {
9257   return builtin_options_as_UnpackOptions();
9258 }
9259
9260 template <>
9261 inline const circle::FloorDivOptions *Operator::builtin_options_as<circle::FloorDivOptions>() const
9262 {
9263   return builtin_options_as_FloorDivOptions();
9264 }
9265
9266 template <>
9267 inline const circle::SquareOptions *Operator::builtin_options_as<circle::SquareOptions>() const
9268 {
9269   return builtin_options_as_SquareOptions();
9270 }
9271
9272 template <>
9273 inline const circle::ZerosLikeOptions *
9274 Operator::builtin_options_as<circle::ZerosLikeOptions>() const
9275 {
9276   return builtin_options_as_ZerosLikeOptions();
9277 }
9278
9279 template <>
9280 inline const circle::FillOptions *Operator::builtin_options_as<circle::FillOptions>() const
9281 {
9282   return builtin_options_as_FillOptions();
9283 }
9284
9285 template <>
9286 inline const circle::BidirectionalSequenceLSTMOptions *
9287 Operator::builtin_options_as<circle::BidirectionalSequenceLSTMOptions>() const
9288 {
9289   return builtin_options_as_BidirectionalSequenceLSTMOptions();
9290 }
9291
9292 template <>
9293 inline const circle::BidirectionalSequenceRNNOptions *
9294 Operator::builtin_options_as<circle::BidirectionalSequenceRNNOptions>() const
9295 {
9296   return builtin_options_as_BidirectionalSequenceRNNOptions();
9297 }
9298
9299 template <>
9300 inline const circle::UnidirectionalSequenceLSTMOptions *
9301 Operator::builtin_options_as<circle::UnidirectionalSequenceLSTMOptions>() const
9302 {
9303   return builtin_options_as_UnidirectionalSequenceLSTMOptions();
9304 }
9305
9306 template <>
9307 inline const circle::FloorModOptions *Operator::builtin_options_as<circle::FloorModOptions>() const
9308 {
9309   return builtin_options_as_FloorModOptions();
9310 }
9311
9312 template <>
9313 inline const circle::RangeOptions *Operator::builtin_options_as<circle::RangeOptions>() const
9314 {
9315   return builtin_options_as_RangeOptions();
9316 }
9317
9318 template <>
9319 inline const circle::ResizeNearestNeighborOptions *
9320 Operator::builtin_options_as<circle::ResizeNearestNeighborOptions>() const
9321 {
9322   return builtin_options_as_ResizeNearestNeighborOptions();
9323 }
9324
9325 template <>
9326 inline const circle::LeakyReluOptions *
9327 Operator::builtin_options_as<circle::LeakyReluOptions>() const
9328 {
9329   return builtin_options_as_LeakyReluOptions();
9330 }
9331
9332 template <>
9333 inline const circle::SquaredDifferenceOptions *
9334 Operator::builtin_options_as<circle::SquaredDifferenceOptions>() const
9335 {
9336   return builtin_options_as_SquaredDifferenceOptions();
9337 }
9338
9339 template <>
9340 inline const circle::MirrorPadOptions *
9341 Operator::builtin_options_as<circle::MirrorPadOptions>() const
9342 {
9343   return builtin_options_as_MirrorPadOptions();
9344 }
9345
9346 template <>
9347 inline const circle::AbsOptions *Operator::builtin_options_as<circle::AbsOptions>() const
9348 {
9349   return builtin_options_as_AbsOptions();
9350 }
9351
9352 template <>
9353 inline const circle::SplitVOptions *Operator::builtin_options_as<circle::SplitVOptions>() const
9354 {
9355   return builtin_options_as_SplitVOptions();
9356 }
9357
9358 template <>
9359 inline const circle::UniqueOptions *Operator::builtin_options_as<circle::UniqueOptions>() const
9360 {
9361   return builtin_options_as_UniqueOptions();
9362 }
9363
9364 template <>
9365 inline const circle::ReverseV2Options *
9366 Operator::builtin_options_as<circle::ReverseV2Options>() const
9367 {
9368   return builtin_options_as_ReverseV2Options();
9369 }
9370
9371 template <>
9372 inline const circle::AddNOptions *Operator::builtin_options_as<circle::AddNOptions>() const
9373 {
9374   return builtin_options_as_AddNOptions();
9375 }
9376
9377 template <>
9378 inline const circle::GatherNdOptions *Operator::builtin_options_as<circle::GatherNdOptions>() const
9379 {
9380   return builtin_options_as_GatherNdOptions();
9381 }
9382
9383 template <>
9384 inline const circle::CosOptions *Operator::builtin_options_as<circle::CosOptions>() const
9385 {
9386   return builtin_options_as_CosOptions();
9387 }
9388
9389 template <>
9390 inline const circle::WhereOptions *Operator::builtin_options_as<circle::WhereOptions>() const
9391 {
9392   return builtin_options_as_WhereOptions();
9393 }
9394
9395 template <>
9396 inline const circle::RankOptions *Operator::builtin_options_as<circle::RankOptions>() const
9397 {
9398   return builtin_options_as_RankOptions();
9399 }
9400
9401 template <>
9402 inline const circle::ReverseSequenceOptions *
9403 Operator::builtin_options_as<circle::ReverseSequenceOptions>() const
9404 {
9405   return builtin_options_as_ReverseSequenceOptions();
9406 }
9407
9408 template <>
9409 inline const circle::MatrixDiagOptions *
9410 Operator::builtin_options_as<circle::MatrixDiagOptions>() const
9411 {
9412   return builtin_options_as_MatrixDiagOptions();
9413 }
9414
9415 template <>
9416 inline const circle::QuantizeOptions *Operator::builtin_options_as<circle::QuantizeOptions>() const
9417 {
9418   return builtin_options_as_QuantizeOptions();
9419 }
9420
9421 template <>
9422 inline const circle::MatrixSetDiagOptions *
9423 Operator::builtin_options_as<circle::MatrixSetDiagOptions>() const
9424 {
9425   return builtin_options_as_MatrixSetDiagOptions();
9426 }
9427
9428 template <>
9429 inline const circle::HardSwishOptions *
9430 Operator::builtin_options_as<circle::HardSwishOptions>() const
9431 {
9432   return builtin_options_as_HardSwishOptions();
9433 }
9434
9435 template <> inline const circle::IfOptions *Operator::builtin_options_as<circle::IfOptions>() const
9436 {
9437   return builtin_options_as_IfOptions();
9438 }
9439
9440 template <>
9441 inline const circle::WhileOptions *Operator::builtin_options_as<circle::WhileOptions>() const
9442 {
9443   return builtin_options_as_WhileOptions();
9444 }
9445
9446 template <>
9447 inline const circle::DepthToSpaceOptions *
9448 Operator::builtin_options_as<circle::DepthToSpaceOptions>() const
9449 {
9450   return builtin_options_as_DepthToSpaceOptions();
9451 }
9452
9453 template <>
9454 inline const circle::NonMaxSuppressionV4Options *
9455 Operator::builtin_options_as<circle::NonMaxSuppressionV4Options>() const
9456 {
9457   return builtin_options_as_NonMaxSuppressionV4Options();
9458 }
9459
9460 template <>
9461 inline const circle::NonMaxSuppressionV5Options *
9462 Operator::builtin_options_as<circle::NonMaxSuppressionV5Options>() const
9463 {
9464   return builtin_options_as_NonMaxSuppressionV5Options();
9465 }
9466
9467 template <>
9468 inline const circle::ScatterNdOptions *
9469 Operator::builtin_options_as<circle::ScatterNdOptions>() const
9470 {
9471   return builtin_options_as_ScatterNdOptions();
9472 }
9473
9474 template <>
9475 inline const circle::SelectV2Options *Operator::builtin_options_as<circle::SelectV2Options>() const
9476 {
9477   return builtin_options_as_SelectV2Options();
9478 }
9479
9480 template <>
9481 inline const circle::DensifyOptions *Operator::builtin_options_as<circle::DensifyOptions>() const
9482 {
9483   return builtin_options_as_DensifyOptions();
9484 }
9485
9486 template <>
9487 inline const circle::SegmentSumOptions *
9488 Operator::builtin_options_as<circle::SegmentSumOptions>() const
9489 {
9490   return builtin_options_as_SegmentSumOptions();
9491 }
9492
9493 template <>
9494 inline const circle::BatchMatMulOptions *
9495 Operator::builtin_options_as<circle::BatchMatMulOptions>() const
9496 {
9497   return builtin_options_as_BatchMatMulOptions();
9498 }
9499
9500 template <>
9501 inline const circle::BCQGatherOptions *
9502 Operator::builtin_options_as<circle::BCQGatherOptions>() const
9503 {
9504   return builtin_options_as_BCQGatherOptions();
9505 }
9506
9507 template <>
9508 inline const circle::BCQFullyConnectedOptions *
9509 Operator::builtin_options_as<circle::BCQFullyConnectedOptions>() const
9510 {
9511   return builtin_options_as_BCQFullyConnectedOptions();
9512 }
9513
9514 template <>
9515 inline const circle::InstanceNormOptions *
9516 Operator::builtin_options_as<circle::InstanceNormOptions>() const
9517 {
9518   return builtin_options_as_InstanceNormOptions();
9519 }
9520
9521 struct OperatorBuilder
9522 {
9523   typedef Operator Table;
9524   flatbuffers::FlatBufferBuilder &fbb_;
9525   flatbuffers::uoffset_t start_;
9526   void add_opcode_index(uint32_t opcode_index)
9527   {
9528     fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
9529   }
9530   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
9531   {
9532     fbb_.AddOffset(Operator::VT_INPUTS, inputs);
9533   }
9534   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
9535   {
9536     fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
9537   }
9538   void add_builtin_options_type(circle::BuiltinOptions builtin_options_type)
9539   {
9540     fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE,
9541                              static_cast<uint8_t>(builtin_options_type), 0);
9542   }
9543   void add_builtin_options(flatbuffers::Offset<void> builtin_options)
9544   {
9545     fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
9546   }
9547   void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options)
9548   {
9549     fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
9550   }
9551   void add_custom_options_format(circle::CustomOptionsFormat custom_options_format)
9552   {
9553     fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT,
9554                             static_cast<int8_t>(custom_options_format), 0);
9555   }
9556   void add_mutating_variable_inputs(
9557     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs)
9558   {
9559     fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
9560   }
9561   void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates)
9562   {
9563     fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
9564   }
9565   explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9566   {
9567     start_ = fbb_.StartTable();
9568   }
9569   OperatorBuilder &operator=(const OperatorBuilder &);
9570   flatbuffers::Offset<Operator> Finish()
9571   {
9572     const auto end = fbb_.EndTable(start_);
9573     auto o = flatbuffers::Offset<Operator>(end);
9574     return o;
9575   }
9576 };
9577
9578 inline flatbuffers::Offset<Operator> CreateOperator(
9579   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
9580   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
9581   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
9582   circle::BuiltinOptions builtin_options_type = circle::BuiltinOptions_NONE,
9583   flatbuffers::Offset<void> builtin_options = 0,
9584   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
9585   circle::CustomOptionsFormat custom_options_format = circle::CustomOptionsFormat_FLEXBUFFERS,
9586   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
9587   flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0)
9588 {
9589   OperatorBuilder builder_(_fbb);
9590   builder_.add_intermediates(intermediates);
9591   builder_.add_mutating_variable_inputs(mutating_variable_inputs);
9592   builder_.add_custom_options(custom_options);
9593   builder_.add_builtin_options(builtin_options);
9594   builder_.add_outputs(outputs);
9595   builder_.add_inputs(inputs);
9596   builder_.add_opcode_index(opcode_index);
9597   builder_.add_custom_options_format(custom_options_format);
9598   builder_.add_builtin_options_type(builtin_options_type);
9599   return builder_.Finish();
9600 }
9601
9602 inline flatbuffers::Offset<Operator> CreateOperatorDirect(
9603   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
9604   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
9605   circle::BuiltinOptions builtin_options_type = circle::BuiltinOptions_NONE,
9606   flatbuffers::Offset<void> builtin_options = 0,
9607   const std::vector<uint8_t> *custom_options = nullptr,
9608   circle::CustomOptionsFormat custom_options_format = circle::CustomOptionsFormat_FLEXBUFFERS,
9609   const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
9610   const std::vector<int32_t> *intermediates = nullptr)
9611 {
9612   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
9613   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
9614   auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
9615   auto mutating_variable_inputs__ =
9616     mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
9617   auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
9618   return circle::CreateOperator(_fbb, opcode_index, inputs__, outputs__, builtin_options_type,
9619                                 builtin_options, custom_options__, custom_options_format,
9620                                 mutating_variable_inputs__, intermediates__);
9621 }
9622
9623 struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9624 {
9625   typedef SubGraphBuilder Builder;
9626   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9627   {
9628     VT_TENSORS = 4,
9629     VT_INPUTS = 6,
9630     VT_OUTPUTS = 8,
9631     VT_OPERATORS = 10,
9632     VT_NAME = 12,
9633     VT_DATA_FORMAT = 14
9634   };
9635   const flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>> *tensors() const
9636   {
9637     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>> *>(VT_TENSORS);
9638   }
9639   const flatbuffers::Vector<int32_t> *inputs() const
9640   {
9641     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
9642   }
9643   const flatbuffers::Vector<int32_t> *outputs() const
9644   {
9645     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
9646   }
9647   const flatbuffers::Vector<flatbuffers::Offset<circle::Operator>> *operators() const
9648   {
9649     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Operator>> *>(
9650       VT_OPERATORS);
9651   }
9652   const flatbuffers::String *name() const
9653   {
9654     return GetPointer<const flatbuffers::String *>(VT_NAME);
9655   }
9656   circle::DataFormat data_format() const
9657   {
9658     return static_cast<circle::DataFormat>(GetField<int8_t>(VT_DATA_FORMAT, 0));
9659   }
9660   bool Verify(flatbuffers::Verifier &verifier) const
9661   {
9662     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) &&
9663            verifier.VerifyVector(tensors()) && verifier.VerifyVectorOfTables(tensors()) &&
9664            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
9665            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
9666            VerifyOffset(verifier, VT_OPERATORS) && verifier.VerifyVector(operators()) &&
9667            verifier.VerifyVectorOfTables(operators()) && VerifyOffset(verifier, VT_NAME) &&
9668            verifier.VerifyString(name()) && VerifyField<int8_t>(verifier, VT_DATA_FORMAT) &&
9669            verifier.EndTable();
9670   }
9671 };
9672
9673 struct SubGraphBuilder
9674 {
9675   typedef SubGraph Table;
9676   flatbuffers::FlatBufferBuilder &fbb_;
9677   flatbuffers::uoffset_t start_;
9678   void
9679   add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>>> tensors)
9680   {
9681     fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
9682   }
9683   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
9684   {
9685     fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
9686   }
9687   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
9688   {
9689     fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
9690   }
9691   void add_operators(
9692     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Operator>>> operators)
9693   {
9694     fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
9695   }
9696   void add_name(flatbuffers::Offset<flatbuffers::String> name)
9697   {
9698     fbb_.AddOffset(SubGraph::VT_NAME, name);
9699   }
9700   void add_data_format(circle::DataFormat data_format)
9701   {
9702     fbb_.AddElement<int8_t>(SubGraph::VT_DATA_FORMAT, static_cast<int8_t>(data_format), 0);
9703   }
9704   explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9705   {
9706     start_ = fbb_.StartTable();
9707   }
9708   SubGraphBuilder &operator=(const SubGraphBuilder &);
9709   flatbuffers::Offset<SubGraph> Finish()
9710   {
9711     const auto end = fbb_.EndTable(start_);
9712     auto o = flatbuffers::Offset<SubGraph>(end);
9713     return o;
9714   }
9715 };
9716
9717 inline flatbuffers::Offset<SubGraph> CreateSubGraph(
9718   flatbuffers::FlatBufferBuilder &_fbb,
9719   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>>> tensors = 0,
9720   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
9721   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
9722   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Operator>>> operators = 0,
9723   flatbuffers::Offset<flatbuffers::String> name = 0,
9724   circle::DataFormat data_format = circle::DataFormat_CHANNELS_LAST)
9725 {
9726   SubGraphBuilder builder_(_fbb);
9727   builder_.add_name(name);
9728   builder_.add_operators(operators);
9729   builder_.add_outputs(outputs);
9730   builder_.add_inputs(inputs);
9731   builder_.add_tensors(tensors);
9732   builder_.add_data_format(data_format);
9733   return builder_.Finish();
9734 }
9735
9736 inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
9737   flatbuffers::FlatBufferBuilder &_fbb,
9738   const std::vector<flatbuffers::Offset<circle::Tensor>> *tensors = nullptr,
9739   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
9740   const std::vector<flatbuffers::Offset<circle::Operator>> *operators = nullptr,
9741   const char *name = nullptr, circle::DataFormat data_format = circle::DataFormat_CHANNELS_LAST)
9742 {
9743   auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<circle::Tensor>>(*tensors) : 0;
9744   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
9745   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
9746   auto operators__ =
9747     operators ? _fbb.CreateVector<flatbuffers::Offset<circle::Operator>>(*operators) : 0;
9748   auto name__ = name ? _fbb.CreateString(name) : 0;
9749   return circle::CreateSubGraph(_fbb, tensors__, inputs__, outputs__, operators__, name__,
9750                                 data_format);
9751 }
9752
9753 struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9754 {
9755   typedef BufferBuilder Builder;
9756   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9757   {
9758     VT_DATA = 4
9759   };
9760   const flatbuffers::Vector<uint8_t> *data() const
9761   {
9762     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
9763   }
9764   bool Verify(flatbuffers::Verifier &verifier) const
9765   {
9766     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) &&
9767            verifier.VerifyVector(data()) && verifier.EndTable();
9768   }
9769 };
9770
9771 struct BufferBuilder
9772 {
9773   typedef Buffer Table;
9774   flatbuffers::FlatBufferBuilder &fbb_;
9775   flatbuffers::uoffset_t start_;
9776   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data)
9777   {
9778     fbb_.AddOffset(Buffer::VT_DATA, data);
9779   }
9780   explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9781   {
9782     start_ = fbb_.StartTable();
9783   }
9784   BufferBuilder &operator=(const BufferBuilder &);
9785   flatbuffers::Offset<Buffer> Finish()
9786   {
9787     const auto end = fbb_.EndTable(start_);
9788     auto o = flatbuffers::Offset<Buffer>(end);
9789     return o;
9790   }
9791 };
9792
9793 inline flatbuffers::Offset<Buffer>
9794 CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb,
9795              flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0)
9796 {
9797   BufferBuilder builder_(_fbb);
9798   builder_.add_data(data);
9799   return builder_.Finish();
9800 }
9801
9802 inline flatbuffers::Offset<Buffer> CreateBufferDirect(flatbuffers::FlatBufferBuilder &_fbb,
9803                                                       const std::vector<uint8_t> *data = nullptr)
9804 {
9805   if (data)
9806   {
9807     _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16);
9808   }
9809   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
9810   return circle::CreateBuffer(_fbb, data__);
9811 }
9812
9813 struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9814 {
9815   typedef MetadataBuilder Builder;
9816   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9817   {
9818     VT_NAME = 4,
9819     VT_BUFFER = 6
9820   };
9821   const flatbuffers::String *name() const
9822   {
9823     return GetPointer<const flatbuffers::String *>(VT_NAME);
9824   }
9825   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
9826   bool Verify(flatbuffers::Verifier &verifier) const
9827   {
9828     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
9829            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_BUFFER) &&
9830            verifier.EndTable();
9831   }
9832 };
9833
9834 struct MetadataBuilder
9835 {
9836   typedef Metadata Table;
9837   flatbuffers::FlatBufferBuilder &fbb_;
9838   flatbuffers::uoffset_t start_;
9839   void add_name(flatbuffers::Offset<flatbuffers::String> name)
9840   {
9841     fbb_.AddOffset(Metadata::VT_NAME, name);
9842   }
9843   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0); }
9844   explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9845   {
9846     start_ = fbb_.StartTable();
9847   }
9848   MetadataBuilder &operator=(const MetadataBuilder &);
9849   flatbuffers::Offset<Metadata> Finish()
9850   {
9851     const auto end = fbb_.EndTable(start_);
9852     auto o = flatbuffers::Offset<Metadata>(end);
9853     return o;
9854   }
9855 };
9856
9857 inline flatbuffers::Offset<Metadata>
9858 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb,
9859                flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t buffer = 0)
9860 {
9861   MetadataBuilder builder_(_fbb);
9862   builder_.add_buffer(buffer);
9863   builder_.add_name(name);
9864   return builder_.Finish();
9865 }
9866
9867 inline flatbuffers::Offset<Metadata> CreateMetadataDirect(flatbuffers::FlatBufferBuilder &_fbb,
9868                                                           const char *name = nullptr,
9869                                                           uint32_t buffer = 0)
9870 {
9871   auto name__ = name ? _fbb.CreateString(name) : 0;
9872   return circle::CreateMetadata(_fbb, name__, buffer);
9873 }
9874
9875 struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9876 {
9877   typedef ModelBuilder Builder;
9878   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9879   {
9880     VT_VERSION = 4,
9881     VT_OPERATOR_CODES = 6,
9882     VT_SUBGRAPHS = 8,
9883     VT_DESCRIPTION = 10,
9884     VT_BUFFERS = 12,
9885     VT_METADATA_BUFFER = 14,
9886     VT_METADATA = 16
9887   };
9888   uint32_t version() const { return GetField<uint32_t>(VT_VERSION, 0); }
9889   const flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>> *operator_codes() const
9890   {
9891     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>> *>(
9892       VT_OPERATOR_CODES);
9893   }
9894   const flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>> *subgraphs() const
9895   {
9896     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>> *>(
9897       VT_SUBGRAPHS);
9898   }
9899   const flatbuffers::String *description() const
9900   {
9901     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
9902   }
9903   const flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>> *buffers() const
9904   {
9905     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>> *>(VT_BUFFERS);
9906   }
9907   const flatbuffers::Vector<int32_t> *metadata_buffer() const
9908   {
9909     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
9910   }
9911   const flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>> *metadata() const
9912   {
9913     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>> *>(
9914       VT_METADATA);
9915   }
9916   bool Verify(flatbuffers::Verifier &verifier) const
9917   {
9918     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_VERSION) &&
9919            VerifyOffset(verifier, VT_OPERATOR_CODES) && verifier.VerifyVector(operator_codes()) &&
9920            verifier.VerifyVectorOfTables(operator_codes()) &&
9921            VerifyOffset(verifier, VT_SUBGRAPHS) && verifier.VerifyVector(subgraphs()) &&
9922            verifier.VerifyVectorOfTables(subgraphs()) && VerifyOffset(verifier, VT_DESCRIPTION) &&
9923            verifier.VerifyString(description()) && VerifyOffset(verifier, VT_BUFFERS) &&
9924            verifier.VerifyVector(buffers()) && verifier.VerifyVectorOfTables(buffers()) &&
9925            VerifyOffset(verifier, VT_METADATA_BUFFER) && verifier.VerifyVector(metadata_buffer()) &&
9926            VerifyOffset(verifier, VT_METADATA) && verifier.VerifyVector(metadata()) &&
9927            verifier.VerifyVectorOfTables(metadata()) && verifier.EndTable();
9928   }
9929 };
9930
9931 struct ModelBuilder
9932 {
9933   typedef Model Table;
9934   flatbuffers::FlatBufferBuilder &fbb_;
9935   flatbuffers::uoffset_t start_;
9936   void add_version(uint32_t version) { fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0); }
9937   void add_operator_codes(
9938     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>>>
9939       operator_codes)
9940   {
9941     fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
9942   }
9943   void add_subgraphs(
9944     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>>> subgraphs)
9945   {
9946     fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
9947   }
9948   void add_description(flatbuffers::Offset<flatbuffers::String> description)
9949   {
9950     fbb_.AddOffset(Model::VT_DESCRIPTION, description);
9951   }
9952   void
9953   add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>>> buffers)
9954   {
9955     fbb_.AddOffset(Model::VT_BUFFERS, buffers);
9956   }
9957   void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer)
9958   {
9959     fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
9960   }
9961   void add_metadata(
9962     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>>> metadata)
9963   {
9964     fbb_.AddOffset(Model::VT_METADATA, metadata);
9965   }
9966   explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9967   {
9968     start_ = fbb_.StartTable();
9969   }
9970   ModelBuilder &operator=(const ModelBuilder &);
9971   flatbuffers::Offset<Model> Finish()
9972   {
9973     const auto end = fbb_.EndTable(start_);
9974     auto o = flatbuffers::Offset<Model>(end);
9975     return o;
9976   }
9977 };
9978
9979 inline flatbuffers::Offset<Model> CreateModel(
9980   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
9981   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>>>
9982     operator_codes = 0,
9983   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>>> subgraphs = 0,
9984   flatbuffers::Offset<flatbuffers::String> description = 0,
9985   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>>> buffers = 0,
9986   flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
9987   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>>> metadata = 0)
9988 {
9989   ModelBuilder builder_(_fbb);
9990   builder_.add_metadata(metadata);
9991   builder_.add_metadata_buffer(metadata_buffer);
9992   builder_.add_buffers(buffers);
9993   builder_.add_description(description);
9994   builder_.add_subgraphs(subgraphs);
9995   builder_.add_operator_codes(operator_codes);
9996   builder_.add_version(version);
9997   return builder_.Finish();
9998 }
9999
10000 inline flatbuffers::Offset<Model> CreateModelDirect(
10001   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
10002   const std::vector<flatbuffers::Offset<circle::OperatorCode>> *operator_codes = nullptr,
10003   const std::vector<flatbuffers::Offset<circle::SubGraph>> *subgraphs = nullptr,
10004   const char *description = nullptr,
10005   const std::vector<flatbuffers::Offset<circle::Buffer>> *buffers = nullptr,
10006   const std::vector<int32_t> *metadata_buffer = nullptr,
10007   const std::vector<flatbuffers::Offset<circle::Metadata>> *metadata = nullptr)
10008 {
10009   auto operator_codes__ =
10010     operator_codes ? _fbb.CreateVector<flatbuffers::Offset<circle::OperatorCode>>(*operator_codes)
10011                    : 0;
10012   auto subgraphs__ =
10013     subgraphs ? _fbb.CreateVector<flatbuffers::Offset<circle::SubGraph>>(*subgraphs) : 0;
10014   auto description__ = description ? _fbb.CreateString(description) : 0;
10015   auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<circle::Buffer>>(*buffers) : 0;
10016   auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
10017   auto metadata__ =
10018     metadata ? _fbb.CreateVector<flatbuffers::Offset<circle::Metadata>>(*metadata) : 0;
10019   return circle::CreateModel(_fbb, version, operator_codes__, subgraphs__, description__, buffers__,
10020                              metadata_buffer__, metadata__);
10021 }
10022
10023 inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
10024                                       QuantizationDetails type)
10025 {
10026   switch (type)
10027   {
10028     case QuantizationDetails_NONE:
10029     {
10030       return true;
10031     }
10032     case QuantizationDetails_CustomQuantization:
10033     {
10034       auto ptr = reinterpret_cast<const circle::CustomQuantization *>(obj);
10035       return verifier.VerifyTable(ptr);
10036     }
10037     default:
10038       return true;
10039   }
10040 }
10041
10042 inline bool
10043 VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
10044                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
10045                                 const flatbuffers::Vector<uint8_t> *types)
10046 {
10047   if (!values || !types)
10048     return !values && !types;
10049   if (values->size() != types->size())
10050     return false;
10051   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
10052   {
10053     if (!VerifyQuantizationDetails(verifier, values->Get(i),
10054                                    types->GetEnum<QuantizationDetails>(i)))
10055     {
10056       return false;
10057     }
10058   }
10059   return true;
10060 }
10061
10062 inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
10063                                     SparseIndexVector type)
10064 {
10065   switch (type)
10066   {
10067     case SparseIndexVector_NONE:
10068     {
10069       return true;
10070     }
10071     case SparseIndexVector_Int32Vector:
10072     {
10073       auto ptr = reinterpret_cast<const circle::Int32Vector *>(obj);
10074       return verifier.VerifyTable(ptr);
10075     }
10076     case SparseIndexVector_Uint16Vector:
10077     {
10078       auto ptr = reinterpret_cast<const circle::Uint16Vector *>(obj);
10079       return verifier.VerifyTable(ptr);
10080     }
10081     case SparseIndexVector_Uint8Vector:
10082     {
10083       auto ptr = reinterpret_cast<const circle::Uint8Vector *>(obj);
10084       return verifier.VerifyTable(ptr);
10085     }
10086     default:
10087       return true;
10088   }
10089 }
10090
10091 inline bool
10092 VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
10093                               const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
10094                               const flatbuffers::Vector<uint8_t> *types)
10095 {
10096   if (!values || !types)
10097     return !values && !types;
10098   if (values->size() != types->size())
10099     return false;
10100   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
10101   {
10102     if (!VerifySparseIndexVector(verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i)))
10103     {
10104       return false;
10105     }
10106   }
10107   return true;
10108 }
10109
10110 inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj,
10111                                  BuiltinOptions type)
10112 {
10113   switch (type)
10114   {
10115     case BuiltinOptions_NONE:
10116     {
10117       return true;
10118     }
10119     case BuiltinOptions_Conv2DOptions:
10120     {
10121       auto ptr = reinterpret_cast<const circle::Conv2DOptions *>(obj);
10122       return verifier.VerifyTable(ptr);
10123     }
10124     case BuiltinOptions_DepthwiseConv2DOptions:
10125     {
10126       auto ptr = reinterpret_cast<const circle::DepthwiseConv2DOptions *>(obj);
10127       return verifier.VerifyTable(ptr);
10128     }
10129     case BuiltinOptions_ConcatEmbeddingsOptions:
10130     {
10131       auto ptr = reinterpret_cast<const circle::ConcatEmbeddingsOptions *>(obj);
10132       return verifier.VerifyTable(ptr);
10133     }
10134     case BuiltinOptions_LSHProjectionOptions:
10135     {
10136       auto ptr = reinterpret_cast<const circle::LSHProjectionOptions *>(obj);
10137       return verifier.VerifyTable(ptr);
10138     }
10139     case BuiltinOptions_Pool2DOptions:
10140     {
10141       auto ptr = reinterpret_cast<const circle::Pool2DOptions *>(obj);
10142       return verifier.VerifyTable(ptr);
10143     }
10144     case BuiltinOptions_SVDFOptions:
10145     {
10146       auto ptr = reinterpret_cast<const circle::SVDFOptions *>(obj);
10147       return verifier.VerifyTable(ptr);
10148     }
10149     case BuiltinOptions_RNNOptions:
10150     {
10151       auto ptr = reinterpret_cast<const circle::RNNOptions *>(obj);
10152       return verifier.VerifyTable(ptr);
10153     }
10154     case BuiltinOptions_FullyConnectedOptions:
10155     {
10156       auto ptr = reinterpret_cast<const circle::FullyConnectedOptions *>(obj);
10157       return verifier.VerifyTable(ptr);
10158     }
10159     case BuiltinOptions_SoftmaxOptions:
10160     {
10161       auto ptr = reinterpret_cast<const circle::SoftmaxOptions *>(obj);
10162       return verifier.VerifyTable(ptr);
10163     }
10164     case BuiltinOptions_ConcatenationOptions:
10165     {
10166       auto ptr = reinterpret_cast<const circle::ConcatenationOptions *>(obj);
10167       return verifier.VerifyTable(ptr);
10168     }
10169     case BuiltinOptions_AddOptions:
10170     {
10171       auto ptr = reinterpret_cast<const circle::AddOptions *>(obj);
10172       return verifier.VerifyTable(ptr);
10173     }
10174     case BuiltinOptions_L2NormOptions:
10175     {
10176       auto ptr = reinterpret_cast<const circle::L2NormOptions *>(obj);
10177       return verifier.VerifyTable(ptr);
10178     }
10179     case BuiltinOptions_LocalResponseNormalizationOptions:
10180     {
10181       auto ptr = reinterpret_cast<const circle::LocalResponseNormalizationOptions *>(obj);
10182       return verifier.VerifyTable(ptr);
10183     }
10184     case BuiltinOptions_LSTMOptions:
10185     {
10186       auto ptr = reinterpret_cast<const circle::LSTMOptions *>(obj);
10187       return verifier.VerifyTable(ptr);
10188     }
10189     case BuiltinOptions_ResizeBilinearOptions:
10190     {
10191       auto ptr = reinterpret_cast<const circle::ResizeBilinearOptions *>(obj);
10192       return verifier.VerifyTable(ptr);
10193     }
10194     case BuiltinOptions_CallOptions:
10195     {
10196       auto ptr = reinterpret_cast<const circle::CallOptions *>(obj);
10197       return verifier.VerifyTable(ptr);
10198     }
10199     case BuiltinOptions_ReshapeOptions:
10200     {
10201       auto ptr = reinterpret_cast<const circle::ReshapeOptions *>(obj);
10202       return verifier.VerifyTable(ptr);
10203     }
10204     case BuiltinOptions_SkipGramOptions:
10205     {
10206       auto ptr = reinterpret_cast<const circle::SkipGramOptions *>(obj);
10207       return verifier.VerifyTable(ptr);
10208     }
10209     case BuiltinOptions_SpaceToDepthOptions:
10210     {
10211       auto ptr = reinterpret_cast<const circle::SpaceToDepthOptions *>(obj);
10212       return verifier.VerifyTable(ptr);
10213     }
10214     case BuiltinOptions_EmbeddingLookupSparseOptions:
10215     {
10216       auto ptr = reinterpret_cast<const circle::EmbeddingLookupSparseOptions *>(obj);
10217       return verifier.VerifyTable(ptr);
10218     }
10219     case BuiltinOptions_MulOptions:
10220     {
10221       auto ptr = reinterpret_cast<const circle::MulOptions *>(obj);
10222       return verifier.VerifyTable(ptr);
10223     }
10224     case BuiltinOptions_PadOptions:
10225     {
10226       auto ptr = reinterpret_cast<const circle::PadOptions *>(obj);
10227       return verifier.VerifyTable(ptr);
10228     }
10229     case BuiltinOptions_GatherOptions:
10230     {
10231       auto ptr = reinterpret_cast<const circle::GatherOptions *>(obj);
10232       return verifier.VerifyTable(ptr);
10233     }
10234     case BuiltinOptions_BatchToSpaceNDOptions:
10235     {
10236       auto ptr = reinterpret_cast<const circle::BatchToSpaceNDOptions *>(obj);
10237       return verifier.VerifyTable(ptr);
10238     }
10239     case BuiltinOptions_SpaceToBatchNDOptions:
10240     {
10241       auto ptr = reinterpret_cast<const circle::SpaceToBatchNDOptions *>(obj);
10242       return verifier.VerifyTable(ptr);
10243     }
10244     case BuiltinOptions_TransposeOptions:
10245     {
10246       auto ptr = reinterpret_cast<const circle::TransposeOptions *>(obj);
10247       return verifier.VerifyTable(ptr);
10248     }
10249     case BuiltinOptions_ReducerOptions:
10250     {
10251       auto ptr = reinterpret_cast<const circle::ReducerOptions *>(obj);
10252       return verifier.VerifyTable(ptr);
10253     }
10254     case BuiltinOptions_SubOptions:
10255     {
10256       auto ptr = reinterpret_cast<const circle::SubOptions *>(obj);
10257       return verifier.VerifyTable(ptr);
10258     }
10259     case BuiltinOptions_DivOptions:
10260     {
10261       auto ptr = reinterpret_cast<const circle::DivOptions *>(obj);
10262       return verifier.VerifyTable(ptr);
10263     }
10264     case BuiltinOptions_SqueezeOptions:
10265     {
10266       auto ptr = reinterpret_cast<const circle::SqueezeOptions *>(obj);
10267       return verifier.VerifyTable(ptr);
10268     }
10269     case BuiltinOptions_SequenceRNNOptions:
10270     {
10271       auto ptr = reinterpret_cast<const circle::SequenceRNNOptions *>(obj);
10272       return verifier.VerifyTable(ptr);
10273     }
10274     case BuiltinOptions_StridedSliceOptions:
10275     {
10276       auto ptr = reinterpret_cast<const circle::StridedSliceOptions *>(obj);
10277       return verifier.VerifyTable(ptr);
10278     }
10279     case BuiltinOptions_ExpOptions:
10280     {
10281       auto ptr = reinterpret_cast<const circle::ExpOptions *>(obj);
10282       return verifier.VerifyTable(ptr);
10283     }
10284     case BuiltinOptions_TopKV2Options:
10285     {
10286       auto ptr = reinterpret_cast<const circle::TopKV2Options *>(obj);
10287       return verifier.VerifyTable(ptr);
10288     }
10289     case BuiltinOptions_SplitOptions:
10290     {
10291       auto ptr = reinterpret_cast<const circle::SplitOptions *>(obj);
10292       return verifier.VerifyTable(ptr);
10293     }
10294     case BuiltinOptions_LogSoftmaxOptions:
10295     {
10296       auto ptr = reinterpret_cast<const circle::LogSoftmaxOptions *>(obj);
10297       return verifier.VerifyTable(ptr);
10298     }
10299     case BuiltinOptions_CastOptions:
10300     {
10301       auto ptr = reinterpret_cast<const circle::CastOptions *>(obj);
10302       return verifier.VerifyTable(ptr);
10303     }
10304     case BuiltinOptions_DequantizeOptions:
10305     {
10306       auto ptr = reinterpret_cast<const circle::DequantizeOptions *>(obj);
10307       return verifier.VerifyTable(ptr);
10308     }
10309     case BuiltinOptions_MaximumMinimumOptions:
10310     {
10311       auto ptr = reinterpret_cast<const circle::MaximumMinimumOptions *>(obj);
10312       return verifier.VerifyTable(ptr);
10313     }
10314     case BuiltinOptions_ArgMaxOptions:
10315     {
10316       auto ptr = reinterpret_cast<const circle::ArgMaxOptions *>(obj);
10317       return verifier.VerifyTable(ptr);
10318     }
10319     case BuiltinOptions_LessOptions:
10320     {
10321       auto ptr = reinterpret_cast<const circle::LessOptions *>(obj);
10322       return verifier.VerifyTable(ptr);
10323     }
10324     case BuiltinOptions_NegOptions:
10325     {
10326       auto ptr = reinterpret_cast<const circle::NegOptions *>(obj);
10327       return verifier.VerifyTable(ptr);
10328     }
10329     case BuiltinOptions_PadV2Options:
10330     {
10331       auto ptr = reinterpret_cast<const circle::PadV2Options *>(obj);
10332       return verifier.VerifyTable(ptr);
10333     }
10334     case BuiltinOptions_GreaterOptions:
10335     {
10336       auto ptr = reinterpret_cast<const circle::GreaterOptions *>(obj);
10337       return verifier.VerifyTable(ptr);
10338     }
10339     case BuiltinOptions_GreaterEqualOptions:
10340     {
10341       auto ptr = reinterpret_cast<const circle::GreaterEqualOptions *>(obj);
10342       return verifier.VerifyTable(ptr);
10343     }
10344     case BuiltinOptions_LessEqualOptions:
10345     {
10346       auto ptr = reinterpret_cast<const circle::LessEqualOptions *>(obj);
10347       return verifier.VerifyTable(ptr);
10348     }
10349     case BuiltinOptions_SelectOptions:
10350     {
10351       auto ptr = reinterpret_cast<const circle::SelectOptions *>(obj);
10352       return verifier.VerifyTable(ptr);
10353     }
10354     case BuiltinOptions_SliceOptions:
10355     {
10356       auto ptr = reinterpret_cast<const circle::SliceOptions *>(obj);
10357       return verifier.VerifyTable(ptr);
10358     }
10359     case BuiltinOptions_TransposeConvOptions:
10360     {
10361       auto ptr = reinterpret_cast<const circle::TransposeConvOptions *>(obj);
10362       return verifier.VerifyTable(ptr);
10363     }
10364     case BuiltinOptions_SparseToDenseOptions:
10365     {
10366       auto ptr = reinterpret_cast<const circle::SparseToDenseOptions *>(obj);
10367       return verifier.VerifyTable(ptr);
10368     }
10369     case BuiltinOptions_TileOptions:
10370     {
10371       auto ptr = reinterpret_cast<const circle::TileOptions *>(obj);
10372       return verifier.VerifyTable(ptr);
10373     }
10374     case BuiltinOptions_ExpandDimsOptions:
10375     {
10376       auto ptr = reinterpret_cast<const circle::ExpandDimsOptions *>(obj);
10377       return verifier.VerifyTable(ptr);
10378     }
10379     case BuiltinOptions_EqualOptions:
10380     {
10381       auto ptr = reinterpret_cast<const circle::EqualOptions *>(obj);
10382       return verifier.VerifyTable(ptr);
10383     }
10384     case BuiltinOptions_NotEqualOptions:
10385     {
10386       auto ptr = reinterpret_cast<const circle::NotEqualOptions *>(obj);
10387       return verifier.VerifyTable(ptr);
10388     }
10389     case BuiltinOptions_ShapeOptions:
10390     {
10391       auto ptr = reinterpret_cast<const circle::ShapeOptions *>(obj);
10392       return verifier.VerifyTable(ptr);
10393     }
10394     case BuiltinOptions_PowOptions:
10395     {
10396       auto ptr = reinterpret_cast<const circle::PowOptions *>(obj);
10397       return verifier.VerifyTable(ptr);
10398     }
10399     case BuiltinOptions_ArgMinOptions:
10400     {
10401       auto ptr = reinterpret_cast<const circle::ArgMinOptions *>(obj);
10402       return verifier.VerifyTable(ptr);
10403     }
10404     case BuiltinOptions_FakeQuantOptions:
10405     {
10406       auto ptr = reinterpret_cast<const circle::FakeQuantOptions *>(obj);
10407       return verifier.VerifyTable(ptr);
10408     }
10409     case BuiltinOptions_PackOptions:
10410     {
10411       auto ptr = reinterpret_cast<const circle::PackOptions *>(obj);
10412       return verifier.VerifyTable(ptr);
10413     }
10414     case BuiltinOptions_LogicalOrOptions:
10415     {
10416       auto ptr = reinterpret_cast<const circle::LogicalOrOptions *>(obj);
10417       return verifier.VerifyTable(ptr);
10418     }
10419     case BuiltinOptions_OneHotOptions:
10420     {
10421       auto ptr = reinterpret_cast<const circle::OneHotOptions *>(obj);
10422       return verifier.VerifyTable(ptr);
10423     }
10424     case BuiltinOptions_LogicalAndOptions:
10425     {
10426       auto ptr = reinterpret_cast<const circle::LogicalAndOptions *>(obj);
10427       return verifier.VerifyTable(ptr);
10428     }
10429     case BuiltinOptions_LogicalNotOptions:
10430     {
10431       auto ptr = reinterpret_cast<const circle::LogicalNotOptions *>(obj);
10432       return verifier.VerifyTable(ptr);
10433     }
10434     case BuiltinOptions_UnpackOptions:
10435     {
10436       auto ptr = reinterpret_cast<const circle::UnpackOptions *>(obj);
10437       return verifier.VerifyTable(ptr);
10438     }
10439     case BuiltinOptions_FloorDivOptions:
10440     {
10441       auto ptr = reinterpret_cast<const circle::FloorDivOptions *>(obj);
10442       return verifier.VerifyTable(ptr);
10443     }
10444     case BuiltinOptions_SquareOptions:
10445     {
10446       auto ptr = reinterpret_cast<const circle::SquareOptions *>(obj);
10447       return verifier.VerifyTable(ptr);
10448     }
10449     case BuiltinOptions_ZerosLikeOptions:
10450     {
10451       auto ptr = reinterpret_cast<const circle::ZerosLikeOptions *>(obj);
10452       return verifier.VerifyTable(ptr);
10453     }
10454     case BuiltinOptions_FillOptions:
10455     {
10456       auto ptr = reinterpret_cast<const circle::FillOptions *>(obj);
10457       return verifier.VerifyTable(ptr);
10458     }
10459     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
10460     {
10461       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceLSTMOptions *>(obj);
10462       return verifier.VerifyTable(ptr);
10463     }
10464     case BuiltinOptions_BidirectionalSequenceRNNOptions:
10465     {
10466       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceRNNOptions *>(obj);
10467       return verifier.VerifyTable(ptr);
10468     }
10469     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
10470     {
10471       auto ptr = reinterpret_cast<const circle::UnidirectionalSequenceLSTMOptions *>(obj);
10472       return verifier.VerifyTable(ptr);
10473     }
10474     case BuiltinOptions_FloorModOptions:
10475     {
10476       auto ptr = reinterpret_cast<const circle::FloorModOptions *>(obj);
10477       return verifier.VerifyTable(ptr);
10478     }
10479     case BuiltinOptions_RangeOptions:
10480     {
10481       auto ptr = reinterpret_cast<const circle::RangeOptions *>(obj);
10482       return verifier.VerifyTable(ptr);
10483     }
10484     case BuiltinOptions_ResizeNearestNeighborOptions:
10485     {
10486       auto ptr = reinterpret_cast<const circle::ResizeNearestNeighborOptions *>(obj);
10487       return verifier.VerifyTable(ptr);
10488     }
10489     case BuiltinOptions_LeakyReluOptions:
10490     {
10491       auto ptr = reinterpret_cast<const circle::LeakyReluOptions *>(obj);
10492       return verifier.VerifyTable(ptr);
10493     }
10494     case BuiltinOptions_SquaredDifferenceOptions:
10495     {
10496       auto ptr = reinterpret_cast<const circle::SquaredDifferenceOptions *>(obj);
10497       return verifier.VerifyTable(ptr);
10498     }
10499     case BuiltinOptions_MirrorPadOptions:
10500     {
10501       auto ptr = reinterpret_cast<const circle::MirrorPadOptions *>(obj);
10502       return verifier.VerifyTable(ptr);
10503     }
10504     case BuiltinOptions_AbsOptions:
10505     {
10506       auto ptr = reinterpret_cast<const circle::AbsOptions *>(obj);
10507       return verifier.VerifyTable(ptr);
10508     }
10509     case BuiltinOptions_SplitVOptions:
10510     {
10511       auto ptr = reinterpret_cast<const circle::SplitVOptions *>(obj);
10512       return verifier.VerifyTable(ptr);
10513     }
10514     case BuiltinOptions_UniqueOptions:
10515     {
10516       auto ptr = reinterpret_cast<const circle::UniqueOptions *>(obj);
10517       return verifier.VerifyTable(ptr);
10518     }
10519     case BuiltinOptions_ReverseV2Options:
10520     {
10521       auto ptr = reinterpret_cast<const circle::ReverseV2Options *>(obj);
10522       return verifier.VerifyTable(ptr);
10523     }
10524     case BuiltinOptions_AddNOptions:
10525     {
10526       auto ptr = reinterpret_cast<const circle::AddNOptions *>(obj);
10527       return verifier.VerifyTable(ptr);
10528     }
10529     case BuiltinOptions_GatherNdOptions:
10530     {
10531       auto ptr = reinterpret_cast<const circle::GatherNdOptions *>(obj);
10532       return verifier.VerifyTable(ptr);
10533     }
10534     case BuiltinOptions_CosOptions:
10535     {
10536       auto ptr = reinterpret_cast<const circle::CosOptions *>(obj);
10537       return verifier.VerifyTable(ptr);
10538     }
10539     case BuiltinOptions_WhereOptions:
10540     {
10541       auto ptr = reinterpret_cast<const circle::WhereOptions *>(obj);
10542       return verifier.VerifyTable(ptr);
10543     }
10544     case BuiltinOptions_RankOptions:
10545     {
10546       auto ptr = reinterpret_cast<const circle::RankOptions *>(obj);
10547       return verifier.VerifyTable(ptr);
10548     }
10549     case BuiltinOptions_ReverseSequenceOptions:
10550     {
10551       auto ptr = reinterpret_cast<const circle::ReverseSequenceOptions *>(obj);
10552       return verifier.VerifyTable(ptr);
10553     }
10554     case BuiltinOptions_MatrixDiagOptions:
10555     {
10556       auto ptr = reinterpret_cast<const circle::MatrixDiagOptions *>(obj);
10557       return verifier.VerifyTable(ptr);
10558     }
10559     case BuiltinOptions_QuantizeOptions:
10560     {
10561       auto ptr = reinterpret_cast<const circle::QuantizeOptions *>(obj);
10562       return verifier.VerifyTable(ptr);
10563     }
10564     case BuiltinOptions_MatrixSetDiagOptions:
10565     {
10566       auto ptr = reinterpret_cast<const circle::MatrixSetDiagOptions *>(obj);
10567       return verifier.VerifyTable(ptr);
10568     }
10569     case BuiltinOptions_HardSwishOptions:
10570     {
10571       auto ptr = reinterpret_cast<const circle::HardSwishOptions *>(obj);
10572       return verifier.VerifyTable(ptr);
10573     }
10574     case BuiltinOptions_IfOptions:
10575     {
10576       auto ptr = reinterpret_cast<const circle::IfOptions *>(obj);
10577       return verifier.VerifyTable(ptr);
10578     }
10579     case BuiltinOptions_WhileOptions:
10580     {
10581       auto ptr = reinterpret_cast<const circle::WhileOptions *>(obj);
10582       return verifier.VerifyTable(ptr);
10583     }
10584     case BuiltinOptions_DepthToSpaceOptions:
10585     {
10586       auto ptr = reinterpret_cast<const circle::DepthToSpaceOptions *>(obj);
10587       return verifier.VerifyTable(ptr);
10588     }
10589     case BuiltinOptions_NonMaxSuppressionV4Options:
10590     {
10591       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV4Options *>(obj);
10592       return verifier.VerifyTable(ptr);
10593     }
10594     case BuiltinOptions_NonMaxSuppressionV5Options:
10595     {
10596       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV5Options *>(obj);
10597       return verifier.VerifyTable(ptr);
10598     }
10599     case BuiltinOptions_ScatterNdOptions:
10600     {
10601       auto ptr = reinterpret_cast<const circle::ScatterNdOptions *>(obj);
10602       return verifier.VerifyTable(ptr);
10603     }
10604     case BuiltinOptions_SelectV2Options:
10605     {
10606       auto ptr = reinterpret_cast<const circle::SelectV2Options *>(obj);
10607       return verifier.VerifyTable(ptr);
10608     }
10609     case BuiltinOptions_DensifyOptions:
10610     {
10611       auto ptr = reinterpret_cast<const circle::DensifyOptions *>(obj);
10612       return verifier.VerifyTable(ptr);
10613     }
10614     case BuiltinOptions_SegmentSumOptions:
10615     {
10616       auto ptr = reinterpret_cast<const circle::SegmentSumOptions *>(obj);
10617       return verifier.VerifyTable(ptr);
10618     }
10619     case BuiltinOptions_BatchMatMulOptions:
10620     {
10621       auto ptr = reinterpret_cast<const circle::BatchMatMulOptions *>(obj);
10622       return verifier.VerifyTable(ptr);
10623     }
10624     case BuiltinOptions_BCQGatherOptions:
10625     {
10626       auto ptr = reinterpret_cast<const circle::BCQGatherOptions *>(obj);
10627       return verifier.VerifyTable(ptr);
10628     }
10629     case BuiltinOptions_BCQFullyConnectedOptions:
10630     {
10631       auto ptr = reinterpret_cast<const circle::BCQFullyConnectedOptions *>(obj);
10632       return verifier.VerifyTable(ptr);
10633     }
10634     case BuiltinOptions_InstanceNormOptions:
10635     {
10636       auto ptr = reinterpret_cast<const circle::InstanceNormOptions *>(obj);
10637       return verifier.VerifyTable(ptr);
10638     }
10639     default:
10640       return true;
10641   }
10642 }
10643
10644 inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
10645                                        const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
10646                                        const flatbuffers::Vector<uint8_t> *types)
10647 {
10648   if (!values || !types)
10649     return !values && !types;
10650   if (values->size() != types->size())
10651     return false;
10652   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
10653   {
10654     if (!VerifyBuiltinOptions(verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i)))
10655     {
10656       return false;
10657     }
10658   }
10659   return true;
10660 }
10661
10662 inline const circle::Model *GetModel(const void *buf)
10663 {
10664   return flatbuffers::GetRoot<circle::Model>(buf);
10665 }
10666
10667 inline const circle::Model *GetSizePrefixedModel(const void *buf)
10668 {
10669   return flatbuffers::GetSizePrefixedRoot<circle::Model>(buf);
10670 }
10671
10672 inline const char *ModelIdentifier() { return "CIR0"; }
10673
10674 inline bool ModelBufferHasIdentifier(const void *buf)
10675 {
10676   return flatbuffers::BufferHasIdentifier(buf, ModelIdentifier());
10677 }
10678
10679 inline bool VerifyModelBuffer(flatbuffers::Verifier &verifier)
10680 {
10681   return verifier.VerifyBuffer<circle::Model>(ModelIdentifier());
10682 }
10683
10684 inline bool VerifySizePrefixedModelBuffer(flatbuffers::Verifier &verifier)
10685 {
10686   return verifier.VerifySizePrefixedBuffer<circle::Model>(ModelIdentifier());
10687 }
10688
10689 inline const char *ModelExtension() { return "circle"; }
10690
10691 inline void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
10692                               flatbuffers::Offset<circle::Model> root)
10693 {
10694   fbb.Finish(root, ModelIdentifier());
10695 }
10696
10697 inline void FinishSizePrefixedModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
10698                                           flatbuffers::Offset<circle::Model> root)
10699 {
10700   fbb.FinishSizePrefixed(root, ModelIdentifier());
10701 }
10702
10703 } // namespace circle
10704
10705 #endif // FLATBUFFERS_GENERATED_CIRCLESCHEMA_CIRCLE_H_