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

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