onert-micro/externals/gen/circle-generated/circle/schema_generated.h

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // automatically generated by the FlatBuffers compiler, do not modify
  18
  19 #ifndef FLATBUFFERS_GENERATED_SCHEMA_CIRCLE_H_
  20 #define FLATBUFFERS_GENERATED_SCHEMA_CIRCLE_H_
  21
  22 #include "flatbuffers/flatbuffers.h"
  23
  24 namespace circle
  25 {
  26
  27 struct CustomQuantization;
  28 struct CustomQuantizationBuilder;
  29 struct CustomQuantizationT;
  30
  31 struct QuantizationParameters;
  32 struct QuantizationParametersBuilder;
  33 struct QuantizationParametersT;
  34
  35 struct Int32Vector;
  36 struct Int32VectorBuilder;
  37 struct Int32VectorT;
  38
  39 struct Uint16Vector;
  40 struct Uint16VectorBuilder;
  41 struct Uint16VectorT;
  42
  43 struct Uint8Vector;
  44 struct Uint8VectorBuilder;
  45 struct Uint8VectorT;
  46
  47 struct DimensionMetadata;
  48 struct DimensionMetadataBuilder;
  49 struct DimensionMetadataT;
  50
  51 struct SparsityParameters;
  52 struct SparsityParametersBuilder;
  53 struct SparsityParametersT;
  54
  55 struct Tensor;
  56 struct TensorBuilder;
  57 struct TensorT;
  58
  59 struct Conv2DOptions;
  60 struct Conv2DOptionsBuilder;
  61 struct Conv2DOptionsT;
  62
  63 struct Conv3DOptions;
  64 struct Conv3DOptionsBuilder;
  65 struct Conv3DOptionsT;
  66
  67 struct Pool2DOptions;
  68 struct Pool2DOptionsBuilder;
  69 struct Pool2DOptionsT;
  70
  71 struct DepthwiseConv2DOptions;
  72 struct DepthwiseConv2DOptionsBuilder;
  73 struct DepthwiseConv2DOptionsT;
  74
  75 struct ConcatEmbeddingsOptions;
  76 struct ConcatEmbeddingsOptionsBuilder;
  77 struct ConcatEmbeddingsOptionsT;
  78
  79 struct LSHProjectionOptions;
  80 struct LSHProjectionOptionsBuilder;
  81 struct LSHProjectionOptionsT;
  82
  83 struct SVDFOptions;
  84 struct SVDFOptionsBuilder;
  85 struct SVDFOptionsT;
  86
  87 struct RNNOptions;
  88 struct RNNOptionsBuilder;
  89 struct RNNOptionsT;
  90
  91 struct SequenceRNNOptions;
  92 struct SequenceRNNOptionsBuilder;
  93 struct SequenceRNNOptionsT;
  94
  95 struct BidirectionalSequenceRNNOptions;
  96 struct BidirectionalSequenceRNNOptionsBuilder;
  97 struct BidirectionalSequenceRNNOptionsT;
  98
  99 struct FullyConnectedOptions;
 100 struct FullyConnectedOptionsBuilder;
 101 struct FullyConnectedOptionsT;
 102
 103 struct SoftmaxOptions;
 104 struct SoftmaxOptionsBuilder;
 105 struct SoftmaxOptionsT;
 106
 107 struct ConcatenationOptions;
 108 struct ConcatenationOptionsBuilder;
 109 struct ConcatenationOptionsT;
 110
 111 struct AddOptions;
 112 struct AddOptionsBuilder;
 113 struct AddOptionsT;
 114
 115 struct MulOptions;
 116 struct MulOptionsBuilder;
 117 struct MulOptionsT;
 118
 119 struct L2NormOptions;
 120 struct L2NormOptionsBuilder;
 121 struct L2NormOptionsT;
 122
 123 struct LocalResponseNormalizationOptions;
 124 struct LocalResponseNormalizationOptionsBuilder;
 125 struct LocalResponseNormalizationOptionsT;
 126
 127 struct LSTMOptions;
 128 struct LSTMOptionsBuilder;
 129 struct LSTMOptionsT;
 130
 131 struct UnidirectionalSequenceLSTMOptions;
 132 struct UnidirectionalSequenceLSTMOptionsBuilder;
 133 struct UnidirectionalSequenceLSTMOptionsT;
 134
 135 struct BidirectionalSequenceLSTMOptions;
 136 struct BidirectionalSequenceLSTMOptionsBuilder;
 137 struct BidirectionalSequenceLSTMOptionsT;
 138
 139 struct ResizeBilinearOptions;
 140 struct ResizeBilinearOptionsBuilder;
 141 struct ResizeBilinearOptionsT;
 142
 143 struct ResizeNearestNeighborOptions;
 144 struct ResizeNearestNeighborOptionsBuilder;
 145 struct ResizeNearestNeighborOptionsT;
 146
 147 struct CallOptions;
 148 struct CallOptionsBuilder;
 149 struct CallOptionsT;
 150
 151 struct PadOptions;
 152 struct PadOptionsBuilder;
 153 struct PadOptionsT;
 154
 155 struct PadV2Options;
 156 struct PadV2OptionsBuilder;
 157 struct PadV2OptionsT;
 158
 159 struct ReshapeOptions;
 160 struct ReshapeOptionsBuilder;
 161 struct ReshapeOptionsT;
 162
 163 struct SpaceToBatchNDOptions;
 164 struct SpaceToBatchNDOptionsBuilder;
 165 struct SpaceToBatchNDOptionsT;
 166
 167 struct BatchToSpaceNDOptions;
 168 struct BatchToSpaceNDOptionsBuilder;
 169 struct BatchToSpaceNDOptionsT;
 170
 171 struct SkipGramOptions;
 172 struct SkipGramOptionsBuilder;
 173 struct SkipGramOptionsT;
 174
 175 struct SpaceToDepthOptions;
 176 struct SpaceToDepthOptionsBuilder;
 177 struct SpaceToDepthOptionsT;
 178
 179 struct DepthToSpaceOptions;
 180 struct DepthToSpaceOptionsBuilder;
 181 struct DepthToSpaceOptionsT;
 182
 183 struct SubOptions;
 184 struct SubOptionsBuilder;
 185 struct SubOptionsT;
 186
 187 struct DivOptions;
 188 struct DivOptionsBuilder;
 189 struct DivOptionsT;
 190
 191 struct TopKV2Options;
 192 struct TopKV2OptionsBuilder;
 193 struct TopKV2OptionsT;
 194
 195 struct EmbeddingLookupSparseOptions;
 196 struct EmbeddingLookupSparseOptionsBuilder;
 197 struct EmbeddingLookupSparseOptionsT;
 198
 199 struct GatherOptions;
 200 struct GatherOptionsBuilder;
 201 struct GatherOptionsT;
 202
 203 struct TransposeOptions;
 204 struct TransposeOptionsBuilder;
 205 struct TransposeOptionsT;
 206
 207 struct ExpOptions;
 208 struct ExpOptionsBuilder;
 209 struct ExpOptionsT;
 210
 211 struct CosOptions;
 212 struct CosOptionsBuilder;
 213 struct CosOptionsT;
 214
 215 struct ReducerOptions;
 216 struct ReducerOptionsBuilder;
 217 struct ReducerOptionsT;
 218
 219 struct SqueezeOptions;
 220 struct SqueezeOptionsBuilder;
 221 struct SqueezeOptionsT;
 222
 223 struct SplitOptions;
 224 struct SplitOptionsBuilder;
 225 struct SplitOptionsT;
 226
 227 struct SplitVOptions;
 228 struct SplitVOptionsBuilder;
 229 struct SplitVOptionsT;
 230
 231 struct StridedSliceOptions;
 232 struct StridedSliceOptionsBuilder;
 233 struct StridedSliceOptionsT;
 234
 235 struct LogSoftmaxOptions;
 236 struct LogSoftmaxOptionsBuilder;
 237 struct LogSoftmaxOptionsT;
 238
 239 struct CastOptions;
 240 struct CastOptionsBuilder;
 241 struct CastOptionsT;
 242
 243 struct DequantizeOptions;
 244 struct DequantizeOptionsBuilder;
 245 struct DequantizeOptionsT;
 246
 247 struct MaximumMinimumOptions;
 248 struct MaximumMinimumOptionsBuilder;
 249 struct MaximumMinimumOptionsT;
 250
 251 struct TileOptions;
 252 struct TileOptionsBuilder;
 253 struct TileOptionsT;
 254
 255 struct ArgMaxOptions;
 256 struct ArgMaxOptionsBuilder;
 257 struct ArgMaxOptionsT;
 258
 259 struct ArgMinOptions;
 260 struct ArgMinOptionsBuilder;
 261 struct ArgMinOptionsT;
 262
 263 struct GreaterOptions;
 264 struct GreaterOptionsBuilder;
 265 struct GreaterOptionsT;
 266
 267 struct GreaterEqualOptions;
 268 struct GreaterEqualOptionsBuilder;
 269 struct GreaterEqualOptionsT;
 270
 271 struct LessOptions;
 272 struct LessOptionsBuilder;
 273 struct LessOptionsT;
 274
 275 struct LessEqualOptions;
 276 struct LessEqualOptionsBuilder;
 277 struct LessEqualOptionsT;
 278
 279 struct NegOptions;
 280 struct NegOptionsBuilder;
 281 struct NegOptionsT;
 282
 283 struct SelectOptions;
 284 struct SelectOptionsBuilder;
 285 struct SelectOptionsT;
 286
 287 struct SliceOptions;
 288 struct SliceOptionsBuilder;
 289 struct SliceOptionsT;
 290
 291 struct TransposeConvOptions;
 292 struct TransposeConvOptionsBuilder;
 293 struct TransposeConvOptionsT;
 294
 295 struct ExpandDimsOptions;
 296 struct ExpandDimsOptionsBuilder;
 297 struct ExpandDimsOptionsT;
 298
 299 struct SparseToDenseOptions;
 300 struct SparseToDenseOptionsBuilder;
 301 struct SparseToDenseOptionsT;
 302
 303 struct EqualOptions;
 304 struct EqualOptionsBuilder;
 305 struct EqualOptionsT;
 306
 307 struct NotEqualOptions;
 308 struct NotEqualOptionsBuilder;
 309 struct NotEqualOptionsT;
 310
 311 struct ShapeOptions;
 312 struct ShapeOptionsBuilder;
 313 struct ShapeOptionsT;
 314
 315 struct RankOptions;
 316 struct RankOptionsBuilder;
 317 struct RankOptionsT;
 318
 319 struct PowOptions;
 320 struct PowOptionsBuilder;
 321 struct PowOptionsT;
 322
 323 struct FakeQuantOptions;
 324 struct FakeQuantOptionsBuilder;
 325 struct FakeQuantOptionsT;
 326
 327 struct PackOptions;
 328 struct PackOptionsBuilder;
 329 struct PackOptionsT;
 330
 331 struct LogicalOrOptions;
 332 struct LogicalOrOptionsBuilder;
 333 struct LogicalOrOptionsT;
 334
 335 struct OneHotOptions;
 336 struct OneHotOptionsBuilder;
 337 struct OneHotOptionsT;
 338
 339 struct AbsOptions;
 340 struct AbsOptionsBuilder;
 341 struct AbsOptionsT;
 342
 343 struct HardSwishOptions;
 344 struct HardSwishOptionsBuilder;
 345 struct HardSwishOptionsT;
 346
 347 struct LogicalAndOptions;
 348 struct LogicalAndOptionsBuilder;
 349 struct LogicalAndOptionsT;
 350
 351 struct LogicalNotOptions;
 352 struct LogicalNotOptionsBuilder;
 353 struct LogicalNotOptionsT;
 354
 355 struct UnpackOptions;
 356 struct UnpackOptionsBuilder;
 357 struct UnpackOptionsT;
 358
 359 struct FloorDivOptions;
 360 struct FloorDivOptionsBuilder;
 361 struct FloorDivOptionsT;
 362
 363 struct SquareOptions;
 364 struct SquareOptionsBuilder;
 365 struct SquareOptionsT;
 366
 367 struct ZerosLikeOptions;
 368 struct ZerosLikeOptionsBuilder;
 369 struct ZerosLikeOptionsT;
 370
 371 struct FillOptions;
 372 struct FillOptionsBuilder;
 373 struct FillOptionsT;
 374
 375 struct FloorModOptions;
 376 struct FloorModOptionsBuilder;
 377 struct FloorModOptionsT;
 378
 379 struct RangeOptions;
 380 struct RangeOptionsBuilder;
 381 struct RangeOptionsT;
 382
 383 struct LeakyReluOptions;
 384 struct LeakyReluOptionsBuilder;
 385 struct LeakyReluOptionsT;
 386
 387 struct SquaredDifferenceOptions;
 388 struct SquaredDifferenceOptionsBuilder;
 389 struct SquaredDifferenceOptionsT;
 390
 391 struct MirrorPadOptions;
 392 struct MirrorPadOptionsBuilder;
 393 struct MirrorPadOptionsT;
 394
 395 struct UniqueOptions;
 396 struct UniqueOptionsBuilder;
 397 struct UniqueOptionsT;
 398
 399 struct ReverseV2Options;
 400 struct ReverseV2OptionsBuilder;
 401 struct ReverseV2OptionsT;
 402
 403 struct AddNOptions;
 404 struct AddNOptionsBuilder;
 405 struct AddNOptionsT;
 406
 407 struct GatherNdOptions;
 408 struct GatherNdOptionsBuilder;
 409 struct GatherNdOptionsT;
 410
 411 struct WhereOptions;
 412 struct WhereOptionsBuilder;
 413 struct WhereOptionsT;
 414
 415 struct ReverseSequenceOptions;
 416 struct ReverseSequenceOptionsBuilder;
 417 struct ReverseSequenceOptionsT;
 418
 419 struct MatrixDiagOptions;
 420 struct MatrixDiagOptionsBuilder;
 421 struct MatrixDiagOptionsT;
 422
 423 struct QuantizeOptions;
 424 struct QuantizeOptionsBuilder;
 425 struct QuantizeOptionsT;
 426
 427 struct MatrixSetDiagOptions;
 428 struct MatrixSetDiagOptionsBuilder;
 429 struct MatrixSetDiagOptionsT;
 430
 431 struct IfOptions;
 432 struct IfOptionsBuilder;
 433 struct IfOptionsT;
 434
 435 struct CallOnceOptions;
 436 struct CallOnceOptionsBuilder;
 437 struct CallOnceOptionsT;
 438
 439 struct WhileOptions;
 440 struct WhileOptionsBuilder;
 441 struct WhileOptionsT;
 442
 443 struct NonMaxSuppressionV4Options;
 444 struct NonMaxSuppressionV4OptionsBuilder;
 445 struct NonMaxSuppressionV4OptionsT;
 446
 447 struct NonMaxSuppressionV5Options;
 448 struct NonMaxSuppressionV5OptionsBuilder;
 449 struct NonMaxSuppressionV5OptionsT;
 450
 451 struct ScatterNdOptions;
 452 struct ScatterNdOptionsBuilder;
 453 struct ScatterNdOptionsT;
 454
 455 struct SelectV2Options;
 456 struct SelectV2OptionsBuilder;
 457 struct SelectV2OptionsT;
 458
 459 struct DensifyOptions;
 460 struct DensifyOptionsBuilder;
 461 struct DensifyOptionsT;
 462
 463 struct SegmentSumOptions;
 464 struct SegmentSumOptionsBuilder;
 465 struct SegmentSumOptionsT;
 466
 467 struct BatchMatMulOptions;
 468 struct BatchMatMulOptionsBuilder;
 469 struct BatchMatMulOptionsT;
 470
 471 struct CumsumOptions;
 472 struct CumsumOptionsBuilder;
 473 struct CumsumOptionsT;
 474
 475 struct BroadcastToOptions;
 476 struct BroadcastToOptionsBuilder;
 477 struct BroadcastToOptionsT;
 478
 479 struct Rfft2dOptions;
 480 struct Rfft2dOptionsBuilder;
 481 struct Rfft2dOptionsT;
 482
 483 struct HashtableOptions;
 484 struct HashtableOptionsBuilder;
 485 struct HashtableOptionsT;
 486
 487 struct HashtableFindOptions;
 488 struct HashtableFindOptionsBuilder;
 489 struct HashtableFindOptionsT;
 490
 491 struct HashtableImportOptions;
 492 struct HashtableImportOptionsBuilder;
 493 struct HashtableImportOptionsT;
 494
 495 struct HashtableSizeOptions;
 496 struct HashtableSizeOptionsBuilder;
 497 struct HashtableSizeOptionsT;
 498
 499 struct VarHandleOptions;
 500 struct VarHandleOptionsBuilder;
 501 struct VarHandleOptionsT;
 502
 503 struct ReadVariableOptions;
 504 struct ReadVariableOptionsBuilder;
 505 struct ReadVariableOptionsT;
 506
 507 struct AssignVariableOptions;
 508 struct AssignVariableOptionsBuilder;
 509 struct AssignVariableOptionsT;
 510
 511 struct RandomOptions;
 512 struct RandomOptionsBuilder;
 513 struct RandomOptionsT;
 514
 515 struct BCQGatherOptions;
 516 struct BCQGatherOptionsBuilder;
 517 struct BCQGatherOptionsT;
 518
 519 struct BCQFullyConnectedOptions;
 520 struct BCQFullyConnectedOptionsBuilder;
 521 struct BCQFullyConnectedOptionsT;
 522
 523 struct InstanceNormOptions;
 524 struct InstanceNormOptionsBuilder;
 525 struct InstanceNormOptionsT;
 526
 527 struct OperatorCode;
 528 struct OperatorCodeBuilder;
 529 struct OperatorCodeT;
 530
 531 struct Operator;
 532 struct OperatorBuilder;
 533 struct OperatorT;
 534
 535 struct SubGraph;
 536 struct SubGraphBuilder;
 537 struct SubGraphT;
 538
 539 struct Buffer;
 540 struct BufferBuilder;
 541 struct BufferT;
 542
 543 struct Metadata;
 544 struct MetadataBuilder;
 545 struct MetadataT;
 546
 547 struct TensorMap;
 548 struct TensorMapBuilder;
 549 struct TensorMapT;
 550
 551 struct SignatureDef;
 552 struct SignatureDefBuilder;
 553 struct SignatureDefT;
 554
 555 struct Model;
 556 struct ModelBuilder;
 557 struct ModelT;
 558
 559 enum TensorType : int8_t
 560 {
 561   TensorType_FLOAT32 = 0,
 562   TensorType_FLOAT16 = 1,
 563   TensorType_INT32 = 2,
 564   TensorType_UINT8 = 3,
 565   TensorType_INT64 = 4,
 566   TensorType_STRING = 5,
 567   TensorType_BOOL = 6,
 568   TensorType_INT16 = 7,
 569   TensorType_COMPLEX64 = 8,
 570   TensorType_INT8 = 9,
 571   TensorType_FLOAT64 = 10,
 572   TensorType_COMPLEX128 = 11,
 573   TensorType_UINT64 = 12,
 574   TensorType_RESOURCE = 13,
 575   TensorType_VARIANT = 14,
 576   TensorType_UINT32 = 15,
 577   TensorType_MIN = TensorType_FLOAT32,
 578   TensorType_MAX = TensorType_UINT32
 579 };
 580
 581 inline const TensorType (&EnumValuesTensorType())[16]
 582 {
 583   static const TensorType values[] = {
 584     TensorType_FLOAT32,   TensorType_FLOAT16,  TensorType_INT32,   TensorType_UINT8,
 585     TensorType_INT64,     TensorType_STRING,   TensorType_BOOL,    TensorType_INT16,
 586     TensorType_COMPLEX64, TensorType_INT8,     TensorType_FLOAT64, TensorType_COMPLEX128,
 587     TensorType_UINT64,    TensorType_RESOURCE, TensorType_VARIANT, TensorType_UINT32};
 588   return values;
 589 }
 590
 591 inline const char *const *EnumNamesTensorType()
 592 {
 593   static const char *const names[17] = {"FLOAT32", "FLOAT16",    "INT32",  "UINT8",     "INT64",
 594                                         "STRING",  "BOOL",       "INT16",  "COMPLEX64", "INT8",
 595                                         "FLOAT64", "COMPLEX128", "UINT64", "RESOURCE",  "VARIANT",
 596                                         "UINT32",  nullptr};
 597   return names;
 598 }
 599
 600 inline const char *EnumNameTensorType(TensorType e)
 601 {
 602   if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT32))
 603     return "";
 604   const size_t index = static_cast<size_t>(e);
 605   return EnumNamesTensorType()[index];
 606 }
 607
 608 enum QuantizationDetails : uint8_t
 609 {
 610   QuantizationDetails_NONE = 0,
 611   QuantizationDetails_CustomQuantization = 1,
 612   QuantizationDetails_MIN = QuantizationDetails_NONE,
 613   QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
 614 };
 615
 616 inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2]
 617 {
 618   static const QuantizationDetails values[] = {QuantizationDetails_NONE,
 619                                                QuantizationDetails_CustomQuantization};
 620   return values;
 621 }
 622
 623 inline const char *const *EnumNamesQuantizationDetails()
 624 {
 625   static const char *const names[3] = {"NONE", "CustomQuantization", nullptr};
 626   return names;
 627 }
 628
 629 inline const char *EnumNameQuantizationDetails(QuantizationDetails e)
 630 {
 631   if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization))
 632     return "";
 633   const size_t index = static_cast<size_t>(e);
 634   return EnumNamesQuantizationDetails()[index];
 635 }
 636
 637 template <typename T> struct QuantizationDetailsTraits
 638 {
 639   static const QuantizationDetails enum_value = QuantizationDetails_NONE;
 640 };
 641
 642 template <> struct QuantizationDetailsTraits<circle::CustomQuantization>
 643 {
 644   static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
 645 };
 646
 647 struct QuantizationDetailsUnion
 648 {
 649   QuantizationDetails type;
 650   void *value;
 651
 652   QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {}
 653   QuantizationDetailsUnion(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
 654     : type(QuantizationDetails_NONE),
 655       value(nullptr)
 656   {
 657     std::swap(type, u.type);
 658     std::swap(value, u.value);
 659   }
 660   QuantizationDetailsUnion(const QuantizationDetailsUnion &);
 661   QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u)
 662   {
 663     QuantizationDetailsUnion t(u);
 664     std::swap(type, t.type);
 665     std::swap(value, t.value);
 666     return *this;
 667   }
 668   QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
 669   {
 670     std::swap(type, u.type);
 671     std::swap(value, u.value);
 672     return *this;
 673   }
 674   ~QuantizationDetailsUnion() { Reset(); }
 675
 676   void Reset();
 677
 678 #ifndef FLATBUFFERS_CPP98_STL
 679   template <typename T> void Set(T &&val)
 680   {
 681     using RT = typename std::remove_reference<T>::type;
 682     Reset();
 683     type = QuantizationDetailsTraits<typename RT::TableType>::enum_value;
 684     if (type != QuantizationDetails_NONE)
 685     {
 686       value = new RT(std::forward<T>(val));
 687     }
 688   }
 689 #endif // FLATBUFFERS_CPP98_STL
 690
 691   static void *UnPack(const void *obj, QuantizationDetails type,
 692                       const flatbuffers::resolver_function_t *resolver);
 693   flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb,
 694                                  const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
 695
 696   circle::CustomQuantizationT *AsCustomQuantization()
 697   {
 698     return type == QuantizationDetails_CustomQuantization
 699              ? reinterpret_cast<circle::CustomQuantizationT *>(value)
 700              : nullptr;
 701   }
 702   const circle::CustomQuantizationT *AsCustomQuantization() const
 703   {
 704     return type == QuantizationDetails_CustomQuantization
 705              ? reinterpret_cast<const circle::CustomQuantizationT *>(value)
 706              : nullptr;
 707   }
 708 };
 709
 710 bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
 711                                QuantizationDetails type);
 712 bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
 713                                      const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 714                                      const flatbuffers::Vector<uint8_t> *types);
 715
 716 enum DimensionType : int8_t
 717 {
 718   DimensionType_DENSE = 0,
 719   DimensionType_SPARSE_CSR = 1,
 720   DimensionType_MIN = DimensionType_DENSE,
 721   DimensionType_MAX = DimensionType_SPARSE_CSR
 722 };
 723
 724 inline const DimensionType (&EnumValuesDimensionType())[2]
 725 {
 726   static const DimensionType values[] = {DimensionType_DENSE, DimensionType_SPARSE_CSR};
 727   return values;
 728 }
 729
 730 inline const char *const *EnumNamesDimensionType()
 731 {
 732   static const char *const names[3] = {"DENSE", "SPARSE_CSR", nullptr};
 733   return names;
 734 }
 735
 736 inline const char *EnumNameDimensionType(DimensionType e)
 737 {
 738   if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR))
 739     return "";
 740   const size_t index = static_cast<size_t>(e);
 741   return EnumNamesDimensionType()[index];
 742 }
 743
 744 enum SparseIndexVector : uint8_t
 745 {
 746   SparseIndexVector_NONE = 0,
 747   SparseIndexVector_Int32Vector = 1,
 748   SparseIndexVector_Uint16Vector = 2,
 749   SparseIndexVector_Uint8Vector = 3,
 750   SparseIndexVector_MIN = SparseIndexVector_NONE,
 751   SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
 752 };
 753
 754 inline const SparseIndexVector (&EnumValuesSparseIndexVector())[4]
 755 {
 756   static const SparseIndexVector values[] = {SparseIndexVector_NONE, SparseIndexVector_Int32Vector,
 757                                              SparseIndexVector_Uint16Vector,
 758                                              SparseIndexVector_Uint8Vector};
 759   return values;
 760 }
 761
 762 inline const char *const *EnumNamesSparseIndexVector()
 763 {
 764   static const char *const names[5] = {"NONE", "Int32Vector", "Uint16Vector", "Uint8Vector",
 765                                        nullptr};
 766   return names;
 767 }
 768
 769 inline const char *EnumNameSparseIndexVector(SparseIndexVector e)
 770 {
 771   if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector))
 772     return "";
 773   const size_t index = static_cast<size_t>(e);
 774   return EnumNamesSparseIndexVector()[index];
 775 }
 776
 777 template <typename T> struct SparseIndexVectorTraits
 778 {
 779   static const SparseIndexVector enum_value = SparseIndexVector_NONE;
 780 };
 781
 782 template <> struct SparseIndexVectorTraits<circle::Int32Vector>
 783 {
 784   static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
 785 };
 786
 787 template <> struct SparseIndexVectorTraits<circle::Uint16Vector>
 788 {
 789   static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
 790 };
 791
 792 template <> struct SparseIndexVectorTraits<circle::Uint8Vector>
 793 {
 794   static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
 795 };
 796
 797 struct SparseIndexVectorUnion
 798 {
 799   SparseIndexVector type;
 800   void *value;
 801
 802   SparseIndexVectorUnion() : type(SparseIndexVector_NONE), value(nullptr) {}
 803   SparseIndexVectorUnion(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
 804     : type(SparseIndexVector_NONE),
 805       value(nullptr)
 806   {
 807     std::swap(type, u.type);
 808     std::swap(value, u.value);
 809   }
 810   SparseIndexVectorUnion(const SparseIndexVectorUnion &);
 811   SparseIndexVectorUnion &operator=(const SparseIndexVectorUnion &u)
 812   {
 813     SparseIndexVectorUnion t(u);
 814     std::swap(type, t.type);
 815     std::swap(value, t.value);
 816     return *this;
 817   }
 818   SparseIndexVectorUnion &operator=(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
 819   {
 820     std::swap(type, u.type);
 821     std::swap(value, u.value);
 822     return *this;
 823   }
 824   ~SparseIndexVectorUnion() { Reset(); }
 825
 826   void Reset();
 827
 828 #ifndef FLATBUFFERS_CPP98_STL
 829   template <typename T> void Set(T &&val)
 830   {
 831     using RT = typename std::remove_reference<T>::type;
 832     Reset();
 833     type = SparseIndexVectorTraits<typename RT::TableType>::enum_value;
 834     if (type != SparseIndexVector_NONE)
 835     {
 836       value = new RT(std::forward<T>(val));
 837     }
 838   }
 839 #endif // FLATBUFFERS_CPP98_STL
 840
 841   static void *UnPack(const void *obj, SparseIndexVector type,
 842                       const flatbuffers::resolver_function_t *resolver);
 843   flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb,
 844                                  const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
 845
 846   circle::Int32VectorT *AsInt32Vector()
 847   {
 848     return type == SparseIndexVector_Int32Vector ? reinterpret_cast<circle::Int32VectorT *>(value)
 849                                                  : nullptr;
 850   }
 851   const circle::Int32VectorT *AsInt32Vector() const
 852   {
 853     return type == SparseIndexVector_Int32Vector
 854              ? reinterpret_cast<const circle::Int32VectorT *>(value)
 855              : nullptr;
 856   }
 857   circle::Uint16VectorT *AsUint16Vector()
 858   {
 859     return type == SparseIndexVector_Uint16Vector ? reinterpret_cast<circle::Uint16VectorT *>(value)
 860                                                   : nullptr;
 861   }
 862   const circle::Uint16VectorT *AsUint16Vector() const
 863   {
 864     return type == SparseIndexVector_Uint16Vector
 865              ? reinterpret_cast<const circle::Uint16VectorT *>(value)
 866              : nullptr;
 867   }
 868   circle::Uint8VectorT *AsUint8Vector()
 869   {
 870     return type == SparseIndexVector_Uint8Vector ? reinterpret_cast<circle::Uint8VectorT *>(value)
 871                                                  : nullptr;
 872   }
 873   const circle::Uint8VectorT *AsUint8Vector() const
 874   {
 875     return type == SparseIndexVector_Uint8Vector
 876              ? reinterpret_cast<const circle::Uint8VectorT *>(value)
 877              : nullptr;
 878   }
 879 };
 880
 881 bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
 882                              SparseIndexVector type);
 883 bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
 884                                    const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
 885                                    const flatbuffers::Vector<uint8_t> *types);
 886
 887 enum BuiltinOperator : int32_t
 888 {
 889   BuiltinOperator_BCQ_GATHER = -4,
 890   BuiltinOperator_BCQ_FULLY_CONNECTED = -3,
 891   BuiltinOperator_INSTANCE_NORM = -2,
 892   BuiltinOperator_ADD = 0,
 893   BuiltinOperator_AVERAGE_POOL_2D = 1,
 894   BuiltinOperator_CONCATENATION = 2,
 895   BuiltinOperator_CONV_2D = 3,
 896   BuiltinOperator_DEPTHWISE_CONV_2D = 4,
 897   BuiltinOperator_DEPTH_TO_SPACE = 5,
 898   BuiltinOperator_DEQUANTIZE = 6,
 899   BuiltinOperator_EMBEDDING_LOOKUP = 7,
 900   BuiltinOperator_FLOOR = 8,
 901   BuiltinOperator_FULLY_CONNECTED = 9,
 902   BuiltinOperator_HASHTABLE_LOOKUP = 10,
 903   BuiltinOperator_L2_NORMALIZATION = 11,
 904   BuiltinOperator_L2_POOL_2D = 12,
 905   BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13,
 906   BuiltinOperator_LOGISTIC = 14,
 907   BuiltinOperator_LSH_PROJECTION = 15,
 908   BuiltinOperator_LSTM = 16,
 909   BuiltinOperator_MAX_POOL_2D = 17,
 910   BuiltinOperator_MUL = 18,
 911   BuiltinOperator_RELU = 19,
 912   BuiltinOperator_RELU_N1_TO_1 = 20,
 913   BuiltinOperator_RELU6 = 21,
 914   BuiltinOperator_RESHAPE = 22,
 915   BuiltinOperator_RESIZE_BILINEAR = 23,
 916   BuiltinOperator_RNN = 24,
 917   BuiltinOperator_SOFTMAX = 25,
 918   BuiltinOperator_SPACE_TO_DEPTH = 26,
 919   BuiltinOperator_SVDF = 27,
 920   BuiltinOperator_TANH = 28,
 921   BuiltinOperator_CONCAT_EMBEDDINGS = 29,
 922   BuiltinOperator_SKIP_GRAM = 30,
 923   BuiltinOperator_CALL = 31,
 924   BuiltinOperator_CUSTOM = 32,
 925   BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33,
 926   BuiltinOperator_PAD = 34,
 927   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35,
 928   BuiltinOperator_GATHER = 36,
 929   BuiltinOperator_BATCH_TO_SPACE_ND = 37,
 930   BuiltinOperator_SPACE_TO_BATCH_ND = 38,
 931   BuiltinOperator_TRANSPOSE = 39,
 932   BuiltinOperator_MEAN = 40,
 933   BuiltinOperator_SUB = 41,
 934   BuiltinOperator_DIV = 42,
 935   BuiltinOperator_SQUEEZE = 43,
 936   BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44,
 937   BuiltinOperator_STRIDED_SLICE = 45,
 938   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46,
 939   BuiltinOperator_EXP = 47,
 940   BuiltinOperator_TOPK_V2 = 48,
 941   BuiltinOperator_SPLIT = 49,
 942   BuiltinOperator_LOG_SOFTMAX = 50,
 943   BuiltinOperator_DELEGATE = 51,
 944   BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52,
 945   BuiltinOperator_CAST = 53,
 946   BuiltinOperator_PRELU = 54,
 947   BuiltinOperator_MAXIMUM = 55,
 948   BuiltinOperator_ARG_MAX = 56,
 949   BuiltinOperator_MINIMUM = 57,
 950   BuiltinOperator_LESS = 58,
 951   BuiltinOperator_NEG = 59,
 952   BuiltinOperator_PADV2 = 60,
 953   BuiltinOperator_GREATER = 61,
 954   BuiltinOperator_GREATER_EQUAL = 62,
 955   BuiltinOperator_LESS_EQUAL = 63,
 956   BuiltinOperator_SELECT = 64,
 957   BuiltinOperator_SLICE = 65,
 958   BuiltinOperator_SIN = 66,
 959   BuiltinOperator_TRANSPOSE_CONV = 67,
 960   BuiltinOperator_SPARSE_TO_DENSE = 68,
 961   BuiltinOperator_TILE = 69,
 962   BuiltinOperator_EXPAND_DIMS = 70,
 963   BuiltinOperator_EQUAL = 71,
 964   BuiltinOperator_NOT_EQUAL = 72,
 965   BuiltinOperator_LOG = 73,
 966   BuiltinOperator_SUM = 74,
 967   BuiltinOperator_SQRT = 75,
 968   BuiltinOperator_RSQRT = 76,
 969   BuiltinOperator_SHAPE = 77,
 970   BuiltinOperator_POW = 78,
 971   BuiltinOperator_ARG_MIN = 79,
 972   BuiltinOperator_FAKE_QUANT = 80,
 973   BuiltinOperator_REDUCE_PROD = 81,
 974   BuiltinOperator_REDUCE_MAX = 82,
 975   BuiltinOperator_PACK = 83,
 976   BuiltinOperator_LOGICAL_OR = 84,
 977   BuiltinOperator_ONE_HOT = 85,
 978   BuiltinOperator_LOGICAL_AND = 86,
 979   BuiltinOperator_LOGICAL_NOT = 87,
 980   BuiltinOperator_UNPACK = 88,
 981   BuiltinOperator_REDUCE_MIN = 89,
 982   BuiltinOperator_FLOOR_DIV = 90,
 983   BuiltinOperator_REDUCE_ANY = 91,
 984   BuiltinOperator_SQUARE = 92,
 985   BuiltinOperator_ZEROS_LIKE = 93,
 986   BuiltinOperator_FILL = 94,
 987   BuiltinOperator_FLOOR_MOD = 95,
 988   BuiltinOperator_RANGE = 96,
 989   BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97,
 990   BuiltinOperator_LEAKY_RELU = 98,
 991   BuiltinOperator_SQUARED_DIFFERENCE = 99,
 992   BuiltinOperator_MIRROR_PAD = 100,
 993   BuiltinOperator_ABS = 101,
 994   BuiltinOperator_SPLIT_V = 102,
 995   BuiltinOperator_UNIQUE = 103,
 996   BuiltinOperator_CEIL = 104,
 997   BuiltinOperator_REVERSE_V2 = 105,
 998   BuiltinOperator_ADD_N = 106,
 999   BuiltinOperator_GATHER_ND = 107,
1000   BuiltinOperator_COS = 108,
1001   BuiltinOperator_WHERE = 109,
1002   BuiltinOperator_RANK = 110,
1003   BuiltinOperator_ELU = 111,
1004   BuiltinOperator_REVERSE_SEQUENCE = 112,
1005   BuiltinOperator_MATRIX_DIAG = 113,
1006   BuiltinOperator_QUANTIZE = 114,
1007   BuiltinOperator_MATRIX_SET_DIAG = 115,
1008   BuiltinOperator_ROUND = 116,
1009   BuiltinOperator_HARD_SWISH = 117,
1010   BuiltinOperator_IF = 118,
1011   BuiltinOperator_WHILE = 119,
1012   BuiltinOperator_NON_MAX_SUPPRESSION_V4 = 120,
1013   BuiltinOperator_NON_MAX_SUPPRESSION_V5 = 121,
1014   BuiltinOperator_SCATTER_ND = 122,
1015   BuiltinOperator_SELECT_V2 = 123,
1016   BuiltinOperator_DENSIFY = 124,
1017   BuiltinOperator_SEGMENT_SUM = 125,
1018   BuiltinOperator_BATCH_MATMUL = 126,
1019   BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES = 127,
1020   BuiltinOperator_CUMSUM = 128,
1021   BuiltinOperator_CALL_ONCE = 129,
1022   BuiltinOperator_BROADCAST_TO = 130,
1023   BuiltinOperator_RFFT2D = 131,
1024   BuiltinOperator_CONV_3D = 132,
1025   BuiltinOperator_IMAG = 133,
1026   BuiltinOperator_REAL = 134,
1027   BuiltinOperator_COMPLEX_ABS = 135,
1028   BuiltinOperator_HASHTABLE = 136,
1029   BuiltinOperator_HASHTABLE_FIND = 137,
1030   BuiltinOperator_HASHTABLE_IMPORT = 138,
1031   BuiltinOperator_HASHTABLE_SIZE = 139,
1032   BuiltinOperator_REDUCE_ALL = 140,
1033   BuiltinOperator_CONV_3D_TRANSPOSE = 141,
1034   BuiltinOperator_VAR_HANDLE = 142,
1035   BuiltinOperator_READ_VARIABLE = 143,
1036   BuiltinOperator_ASSIGN_VARIABLE = 144,
1037   BuiltinOperator_BROADCAST_ARGS = 145,
1038   BuiltinOperator_RANDOM_STANDARD_NORMAL = 146,
1039   BuiltinOperator_MIN = BuiltinOperator_BCQ_GATHER,
1040   BuiltinOperator_MAX = BuiltinOperator_RANDOM_STANDARD_NORMAL
1041 };
1042
1043 inline const BuiltinOperator (&EnumValuesBuiltinOperator())[150]
1044 {
1045   static const BuiltinOperator values[] = {BuiltinOperator_BCQ_GATHER,
1046                                            BuiltinOperator_BCQ_FULLY_CONNECTED,
1047                                            BuiltinOperator_INSTANCE_NORM,
1048                                            BuiltinOperator_ADD,
1049                                            BuiltinOperator_AVERAGE_POOL_2D,
1050                                            BuiltinOperator_CONCATENATION,
1051                                            BuiltinOperator_CONV_2D,
1052                                            BuiltinOperator_DEPTHWISE_CONV_2D,
1053                                            BuiltinOperator_DEPTH_TO_SPACE,
1054                                            BuiltinOperator_DEQUANTIZE,
1055                                            BuiltinOperator_EMBEDDING_LOOKUP,
1056                                            BuiltinOperator_FLOOR,
1057                                            BuiltinOperator_FULLY_CONNECTED,
1058                                            BuiltinOperator_HASHTABLE_LOOKUP,
1059                                            BuiltinOperator_L2_NORMALIZATION,
1060                                            BuiltinOperator_L2_POOL_2D,
1061                                            BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
1062                                            BuiltinOperator_LOGISTIC,
1063                                            BuiltinOperator_LSH_PROJECTION,
1064                                            BuiltinOperator_LSTM,
1065                                            BuiltinOperator_MAX_POOL_2D,
1066                                            BuiltinOperator_MUL,
1067                                            BuiltinOperator_RELU,
1068                                            BuiltinOperator_RELU_N1_TO_1,
1069                                            BuiltinOperator_RELU6,
1070                                            BuiltinOperator_RESHAPE,
1071                                            BuiltinOperator_RESIZE_BILINEAR,
1072                                            BuiltinOperator_RNN,
1073                                            BuiltinOperator_SOFTMAX,
1074                                            BuiltinOperator_SPACE_TO_DEPTH,
1075                                            BuiltinOperator_SVDF,
1076                                            BuiltinOperator_TANH,
1077                                            BuiltinOperator_CONCAT_EMBEDDINGS,
1078                                            BuiltinOperator_SKIP_GRAM,
1079                                            BuiltinOperator_CALL,
1080                                            BuiltinOperator_CUSTOM,
1081                                            BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
1082                                            BuiltinOperator_PAD,
1083                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
1084                                            BuiltinOperator_GATHER,
1085                                            BuiltinOperator_BATCH_TO_SPACE_ND,
1086                                            BuiltinOperator_SPACE_TO_BATCH_ND,
1087                                            BuiltinOperator_TRANSPOSE,
1088                                            BuiltinOperator_MEAN,
1089                                            BuiltinOperator_SUB,
1090                                            BuiltinOperator_DIV,
1091                                            BuiltinOperator_SQUEEZE,
1092                                            BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
1093                                            BuiltinOperator_STRIDED_SLICE,
1094                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
1095                                            BuiltinOperator_EXP,
1096                                            BuiltinOperator_TOPK_V2,
1097                                            BuiltinOperator_SPLIT,
1098                                            BuiltinOperator_LOG_SOFTMAX,
1099                                            BuiltinOperator_DELEGATE,
1100                                            BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
1101                                            BuiltinOperator_CAST,
1102                                            BuiltinOperator_PRELU,
1103                                            BuiltinOperator_MAXIMUM,
1104                                            BuiltinOperator_ARG_MAX,
1105                                            BuiltinOperator_MINIMUM,
1106                                            BuiltinOperator_LESS,
1107                                            BuiltinOperator_NEG,
1108                                            BuiltinOperator_PADV2,
1109                                            BuiltinOperator_GREATER,
1110                                            BuiltinOperator_GREATER_EQUAL,
1111                                            BuiltinOperator_LESS_EQUAL,
1112                                            BuiltinOperator_SELECT,
1113                                            BuiltinOperator_SLICE,
1114                                            BuiltinOperator_SIN,
1115                                            BuiltinOperator_TRANSPOSE_CONV,
1116                                            BuiltinOperator_SPARSE_TO_DENSE,
1117                                            BuiltinOperator_TILE,
1118                                            BuiltinOperator_EXPAND_DIMS,
1119                                            BuiltinOperator_EQUAL,
1120                                            BuiltinOperator_NOT_EQUAL,
1121                                            BuiltinOperator_LOG,
1122                                            BuiltinOperator_SUM,
1123                                            BuiltinOperator_SQRT,
1124                                            BuiltinOperator_RSQRT,
1125                                            BuiltinOperator_SHAPE,
1126                                            BuiltinOperator_POW,
1127                                            BuiltinOperator_ARG_MIN,
1128                                            BuiltinOperator_FAKE_QUANT,
1129                                            BuiltinOperator_REDUCE_PROD,
1130                                            BuiltinOperator_REDUCE_MAX,
1131                                            BuiltinOperator_PACK,
1132                                            BuiltinOperator_LOGICAL_OR,
1133                                            BuiltinOperator_ONE_HOT,
1134                                            BuiltinOperator_LOGICAL_AND,
1135                                            BuiltinOperator_LOGICAL_NOT,
1136                                            BuiltinOperator_UNPACK,
1137                                            BuiltinOperator_REDUCE_MIN,
1138                                            BuiltinOperator_FLOOR_DIV,
1139                                            BuiltinOperator_REDUCE_ANY,
1140                                            BuiltinOperator_SQUARE,
1141                                            BuiltinOperator_ZEROS_LIKE,
1142                                            BuiltinOperator_FILL,
1143                                            BuiltinOperator_FLOOR_MOD,
1144                                            BuiltinOperator_RANGE,
1145                                            BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
1146                                            BuiltinOperator_LEAKY_RELU,
1147                                            BuiltinOperator_SQUARED_DIFFERENCE,
1148                                            BuiltinOperator_MIRROR_PAD,
1149                                            BuiltinOperator_ABS,
1150                                            BuiltinOperator_SPLIT_V,
1151                                            BuiltinOperator_UNIQUE,
1152                                            BuiltinOperator_CEIL,
1153                                            BuiltinOperator_REVERSE_V2,
1154                                            BuiltinOperator_ADD_N,
1155                                            BuiltinOperator_GATHER_ND,
1156                                            BuiltinOperator_COS,
1157                                            BuiltinOperator_WHERE,
1158                                            BuiltinOperator_RANK,
1159                                            BuiltinOperator_ELU,
1160                                            BuiltinOperator_REVERSE_SEQUENCE,
1161                                            BuiltinOperator_MATRIX_DIAG,
1162                                            BuiltinOperator_QUANTIZE,
1163                                            BuiltinOperator_MATRIX_SET_DIAG,
1164                                            BuiltinOperator_ROUND,
1165                                            BuiltinOperator_HARD_SWISH,
1166                                            BuiltinOperator_IF,
1167                                            BuiltinOperator_WHILE,
1168                                            BuiltinOperator_NON_MAX_SUPPRESSION_V4,
1169                                            BuiltinOperator_NON_MAX_SUPPRESSION_V5,
1170                                            BuiltinOperator_SCATTER_ND,
1171                                            BuiltinOperator_SELECT_V2,
1172                                            BuiltinOperator_DENSIFY,
1173                                            BuiltinOperator_SEGMENT_SUM,
1174                                            BuiltinOperator_BATCH_MATMUL,
1175                                            BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES,
1176                                            BuiltinOperator_CUMSUM,
1177                                            BuiltinOperator_CALL_ONCE,
1178                                            BuiltinOperator_BROADCAST_TO,
1179                                            BuiltinOperator_RFFT2D,
1180                                            BuiltinOperator_CONV_3D,
1181                                            BuiltinOperator_IMAG,
1182                                            BuiltinOperator_REAL,
1183                                            BuiltinOperator_COMPLEX_ABS,
1184                                            BuiltinOperator_HASHTABLE,
1185                                            BuiltinOperator_HASHTABLE_FIND,
1186                                            BuiltinOperator_HASHTABLE_IMPORT,
1187                                            BuiltinOperator_HASHTABLE_SIZE,
1188                                            BuiltinOperator_REDUCE_ALL,
1189                                            BuiltinOperator_CONV_3D_TRANSPOSE,
1190                                            BuiltinOperator_VAR_HANDLE,
1191                                            BuiltinOperator_READ_VARIABLE,
1192                                            BuiltinOperator_ASSIGN_VARIABLE,
1193                                            BuiltinOperator_BROADCAST_ARGS,
1194                                            BuiltinOperator_RANDOM_STANDARD_NORMAL};
1195   return values;
1196 }
1197
1198 inline const char *const *EnumNamesBuiltinOperator()
1199 {
1200   static const char *const names[152] = {"BCQ_GATHER",
1201                                          "BCQ_FULLY_CONNECTED",
1202                                          "INSTANCE_NORM",
1203                                          "",
1204                                          "ADD",
1205                                          "AVERAGE_POOL_2D",
1206                                          "CONCATENATION",
1207                                          "CONV_2D",
1208                                          "DEPTHWISE_CONV_2D",
1209                                          "DEPTH_TO_SPACE",
1210                                          "DEQUANTIZE",
1211                                          "EMBEDDING_LOOKUP",
1212                                          "FLOOR",
1213                                          "FULLY_CONNECTED",
1214                                          "HASHTABLE_LOOKUP",
1215                                          "L2_NORMALIZATION",
1216                                          "L2_POOL_2D",
1217                                          "LOCAL_RESPONSE_NORMALIZATION",
1218                                          "LOGISTIC",
1219                                          "LSH_PROJECTION",
1220                                          "LSTM",
1221                                          "MAX_POOL_2D",
1222                                          "MUL",
1223                                          "RELU",
1224                                          "RELU_N1_TO_1",
1225                                          "RELU6",
1226                                          "RESHAPE",
1227                                          "RESIZE_BILINEAR",
1228                                          "RNN",
1229                                          "SOFTMAX",
1230                                          "SPACE_TO_DEPTH",
1231                                          "SVDF",
1232                                          "TANH",
1233                                          "CONCAT_EMBEDDINGS",
1234                                          "SKIP_GRAM",
1235                                          "CALL",
1236                                          "CUSTOM",
1237                                          "EMBEDDING_LOOKUP_SPARSE",
1238                                          "PAD",
1239                                          "UNIDIRECTIONAL_SEQUENCE_RNN",
1240                                          "GATHER",
1241                                          "BATCH_TO_SPACE_ND",
1242                                          "SPACE_TO_BATCH_ND",
1243                                          "TRANSPOSE",
1244                                          "MEAN",
1245                                          "SUB",
1246                                          "DIV",
1247                                          "SQUEEZE",
1248                                          "UNIDIRECTIONAL_SEQUENCE_LSTM",
1249                                          "STRIDED_SLICE",
1250                                          "BIDIRECTIONAL_SEQUENCE_RNN",
1251                                          "EXP",
1252                                          "TOPK_V2",
1253                                          "SPLIT",
1254                                          "LOG_SOFTMAX",
1255                                          "DELEGATE",
1256                                          "BIDIRECTIONAL_SEQUENCE_LSTM",
1257                                          "CAST",
1258                                          "PRELU",
1259                                          "MAXIMUM",
1260                                          "ARG_MAX",
1261                                          "MINIMUM",
1262                                          "LESS",
1263                                          "NEG",
1264                                          "PADV2",
1265                                          "GREATER",
1266                                          "GREATER_EQUAL",
1267                                          "LESS_EQUAL",
1268                                          "SELECT",
1269                                          "SLICE",
1270                                          "SIN",
1271                                          "TRANSPOSE_CONV",
1272                                          "SPARSE_TO_DENSE",
1273                                          "TILE",
1274                                          "EXPAND_DIMS",
1275                                          "EQUAL",
1276                                          "NOT_EQUAL",
1277                                          "LOG",
1278                                          "SUM",
1279                                          "SQRT",
1280                                          "RSQRT",
1281                                          "SHAPE",
1282                                          "POW",
1283                                          "ARG_MIN",
1284                                          "FAKE_QUANT",
1285                                          "REDUCE_PROD",
1286                                          "REDUCE_MAX",
1287                                          "PACK",
1288                                          "LOGICAL_OR",
1289                                          "ONE_HOT",
1290                                          "LOGICAL_AND",
1291                                          "LOGICAL_NOT",
1292                                          "UNPACK",
1293                                          "REDUCE_MIN",
1294                                          "FLOOR_DIV",
1295                                          "REDUCE_ANY",
1296                                          "SQUARE",
1297                                          "ZEROS_LIKE",
1298                                          "FILL",
1299                                          "FLOOR_MOD",
1300                                          "RANGE",
1301                                          "RESIZE_NEAREST_NEIGHBOR",
1302                                          "LEAKY_RELU",
1303                                          "SQUARED_DIFFERENCE",
1304                                          "MIRROR_PAD",
1305                                          "ABS",
1306                                          "SPLIT_V",
1307                                          "UNIQUE",
1308                                          "CEIL",
1309                                          "REVERSE_V2",
1310                                          "ADD_N",
1311                                          "GATHER_ND",
1312                                          "COS",
1313                                          "WHERE",
1314                                          "RANK",
1315                                          "ELU",
1316                                          "REVERSE_SEQUENCE",
1317                                          "MATRIX_DIAG",
1318                                          "QUANTIZE",
1319                                          "MATRIX_SET_DIAG",
1320                                          "ROUND",
1321                                          "HARD_SWISH",
1322                                          "IF",
1323                                          "WHILE",
1324                                          "NON_MAX_SUPPRESSION_V4",
1325                                          "NON_MAX_SUPPRESSION_V5",
1326                                          "SCATTER_ND",
1327                                          "SELECT_V2",
1328                                          "DENSIFY",
1329                                          "SEGMENT_SUM",
1330                                          "BATCH_MATMUL",
1331                                          "PLACEHOLDER_FOR_GREATER_OP_CODES",
1332                                          "CUMSUM",
1333                                          "CALL_ONCE",
1334                                          "BROADCAST_TO",
1335                                          "RFFT2D",
1336                                          "CONV_3D",
1337                                          "IMAG",
1338                                          "REAL",
1339                                          "COMPLEX_ABS",
1340                                          "HASHTABLE",
1341                                          "HASHTABLE_FIND",
1342                                          "HASHTABLE_IMPORT",
1343                                          "HASHTABLE_SIZE",
1344                                          "REDUCE_ALL",
1345                                          "CONV_3D_TRANSPOSE",
1346                                          "VAR_HANDLE",
1347                                          "READ_VARIABLE",
1348                                          "ASSIGN_VARIABLE",
1349                                          "BROADCAST_ARGS",
1350                                          "RANDOM_STANDARD_NORMAL",
1351                                          nullptr};
1352   return names;
1353 }
1354
1355 inline const char *EnumNameBuiltinOperator(BuiltinOperator e)
1356 {
1357   if (flatbuffers::IsOutRange(e, BuiltinOperator_BCQ_GATHER,
1358                               BuiltinOperator_RANDOM_STANDARD_NORMAL))
1359     return "";
1360   const size_t index = static_cast<size_t>(e) - static_cast<size_t>(BuiltinOperator_BCQ_GATHER);
1361   return EnumNamesBuiltinOperator()[index];
1362 }
1363
1364 enum BuiltinOptions : uint8_t
1365 {
1366   BuiltinOptions_NONE = 0,
1367   BuiltinOptions_Conv2DOptions = 1,
1368   BuiltinOptions_DepthwiseConv2DOptions = 2,
1369   BuiltinOptions_ConcatEmbeddingsOptions = 3,
1370   BuiltinOptions_LSHProjectionOptions = 4,
1371   BuiltinOptions_Pool2DOptions = 5,
1372   BuiltinOptions_SVDFOptions = 6,
1373   BuiltinOptions_RNNOptions = 7,
1374   BuiltinOptions_FullyConnectedOptions = 8,
1375   BuiltinOptions_SoftmaxOptions = 9,
1376   BuiltinOptions_ConcatenationOptions = 10,
1377   BuiltinOptions_AddOptions = 11,
1378   BuiltinOptions_L2NormOptions = 12,
1379   BuiltinOptions_LocalResponseNormalizationOptions = 13,
1380   BuiltinOptions_LSTMOptions = 14,
1381   BuiltinOptions_ResizeBilinearOptions = 15,
1382   BuiltinOptions_CallOptions = 16,
1383   BuiltinOptions_ReshapeOptions = 17,
1384   BuiltinOptions_SkipGramOptions = 18,
1385   BuiltinOptions_SpaceToDepthOptions = 19,
1386   BuiltinOptions_EmbeddingLookupSparseOptions = 20,
1387   BuiltinOptions_MulOptions = 21,
1388   BuiltinOptions_PadOptions = 22,
1389   BuiltinOptions_GatherOptions = 23,
1390   BuiltinOptions_BatchToSpaceNDOptions = 24,
1391   BuiltinOptions_SpaceToBatchNDOptions = 25,
1392   BuiltinOptions_TransposeOptions = 26,
1393   BuiltinOptions_ReducerOptions = 27,
1394   BuiltinOptions_SubOptions = 28,
1395   BuiltinOptions_DivOptions = 29,
1396   BuiltinOptions_SqueezeOptions = 30,
1397   BuiltinOptions_SequenceRNNOptions = 31,
1398   BuiltinOptions_StridedSliceOptions = 32,
1399   BuiltinOptions_ExpOptions = 33,
1400   BuiltinOptions_TopKV2Options = 34,
1401   BuiltinOptions_SplitOptions = 35,
1402   BuiltinOptions_LogSoftmaxOptions = 36,
1403   BuiltinOptions_CastOptions = 37,
1404   BuiltinOptions_DequantizeOptions = 38,
1405   BuiltinOptions_MaximumMinimumOptions = 39,
1406   BuiltinOptions_ArgMaxOptions = 40,
1407   BuiltinOptions_LessOptions = 41,
1408   BuiltinOptions_NegOptions = 42,
1409   BuiltinOptions_PadV2Options = 43,
1410   BuiltinOptions_GreaterOptions = 44,
1411   BuiltinOptions_GreaterEqualOptions = 45,
1412   BuiltinOptions_LessEqualOptions = 46,
1413   BuiltinOptions_SelectOptions = 47,
1414   BuiltinOptions_SliceOptions = 48,
1415   BuiltinOptions_TransposeConvOptions = 49,
1416   BuiltinOptions_SparseToDenseOptions = 50,
1417   BuiltinOptions_TileOptions = 51,
1418   BuiltinOptions_ExpandDimsOptions = 52,
1419   BuiltinOptions_EqualOptions = 53,
1420   BuiltinOptions_NotEqualOptions = 54,
1421   BuiltinOptions_ShapeOptions = 55,
1422   BuiltinOptions_PowOptions = 56,
1423   BuiltinOptions_ArgMinOptions = 57,
1424   BuiltinOptions_FakeQuantOptions = 58,
1425   BuiltinOptions_PackOptions = 59,
1426   BuiltinOptions_LogicalOrOptions = 60,
1427   BuiltinOptions_OneHotOptions = 61,
1428   BuiltinOptions_LogicalAndOptions = 62,
1429   BuiltinOptions_LogicalNotOptions = 63,
1430   BuiltinOptions_UnpackOptions = 64,
1431   BuiltinOptions_FloorDivOptions = 65,
1432   BuiltinOptions_SquareOptions = 66,
1433   BuiltinOptions_ZerosLikeOptions = 67,
1434   BuiltinOptions_FillOptions = 68,
1435   BuiltinOptions_BidirectionalSequenceLSTMOptions = 69,
1436   BuiltinOptions_BidirectionalSequenceRNNOptions = 70,
1437   BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71,
1438   BuiltinOptions_FloorModOptions = 72,
1439   BuiltinOptions_RangeOptions = 73,
1440   BuiltinOptions_ResizeNearestNeighborOptions = 74,
1441   BuiltinOptions_LeakyReluOptions = 75,
1442   BuiltinOptions_SquaredDifferenceOptions = 76,
1443   BuiltinOptions_MirrorPadOptions = 77,
1444   BuiltinOptions_AbsOptions = 78,
1445   BuiltinOptions_SplitVOptions = 79,
1446   BuiltinOptions_UniqueOptions = 80,
1447   BuiltinOptions_ReverseV2Options = 81,
1448   BuiltinOptions_AddNOptions = 82,
1449   BuiltinOptions_GatherNdOptions = 83,
1450   BuiltinOptions_CosOptions = 84,
1451   BuiltinOptions_WhereOptions = 85,
1452   BuiltinOptions_RankOptions = 86,
1453   BuiltinOptions_ReverseSequenceOptions = 87,
1454   BuiltinOptions_MatrixDiagOptions = 88,
1455   BuiltinOptions_QuantizeOptions = 89,
1456   BuiltinOptions_MatrixSetDiagOptions = 90,
1457   BuiltinOptions_HardSwishOptions = 91,
1458   BuiltinOptions_IfOptions = 92,
1459   BuiltinOptions_WhileOptions = 93,
1460   BuiltinOptions_DepthToSpaceOptions = 94,
1461   BuiltinOptions_NonMaxSuppressionV4Options = 95,
1462   BuiltinOptions_NonMaxSuppressionV5Options = 96,
1463   BuiltinOptions_ScatterNdOptions = 97,
1464   BuiltinOptions_SelectV2Options = 98,
1465   BuiltinOptions_DensifyOptions = 99,
1466   BuiltinOptions_SegmentSumOptions = 100,
1467   BuiltinOptions_BatchMatMulOptions = 101,
1468   BuiltinOptions_CumsumOptions = 102,
1469   BuiltinOptions_CallOnceOptions = 103,
1470   BuiltinOptions_BroadcastToOptions = 104,
1471   BuiltinOptions_Rfft2dOptions = 105,
1472   BuiltinOptions_Conv3DOptions = 106,
1473   BuiltinOptions_HashtableOptions = 107,
1474   BuiltinOptions_HashtableFindOptions = 108,
1475   BuiltinOptions_HashtableImportOptions = 109,
1476   BuiltinOptions_HashtableSizeOptions = 110,
1477   BuiltinOptions_VarHandleOptions = 111,
1478   BuiltinOptions_ReadVariableOptions = 112,
1479   BuiltinOptions_AssignVariableOptions = 113,
1480   BuiltinOptions_RandomOptions = 114,
1481   BuiltinOptions_BCQGatherOptions = 252,
1482   BuiltinOptions_BCQFullyConnectedOptions = 253,
1483   BuiltinOptions_InstanceNormOptions = 254,
1484   BuiltinOptions_MIN = BuiltinOptions_NONE,
1485   BuiltinOptions_MAX = BuiltinOptions_InstanceNormOptions
1486 };
1487
1488 inline const BuiltinOptions (&EnumValuesBuiltinOptions())[118]
1489 {
1490   static const BuiltinOptions values[] = {BuiltinOptions_NONE,
1491                                           BuiltinOptions_Conv2DOptions,
1492                                           BuiltinOptions_DepthwiseConv2DOptions,
1493                                           BuiltinOptions_ConcatEmbeddingsOptions,
1494                                           BuiltinOptions_LSHProjectionOptions,
1495                                           BuiltinOptions_Pool2DOptions,
1496                                           BuiltinOptions_SVDFOptions,
1497                                           BuiltinOptions_RNNOptions,
1498                                           BuiltinOptions_FullyConnectedOptions,
1499                                           BuiltinOptions_SoftmaxOptions,
1500                                           BuiltinOptions_ConcatenationOptions,
1501                                           BuiltinOptions_AddOptions,
1502                                           BuiltinOptions_L2NormOptions,
1503                                           BuiltinOptions_LocalResponseNormalizationOptions,
1504                                           BuiltinOptions_LSTMOptions,
1505                                           BuiltinOptions_ResizeBilinearOptions,
1506                                           BuiltinOptions_CallOptions,
1507                                           BuiltinOptions_ReshapeOptions,
1508                                           BuiltinOptions_SkipGramOptions,
1509                                           BuiltinOptions_SpaceToDepthOptions,
1510                                           BuiltinOptions_EmbeddingLookupSparseOptions,
1511                                           BuiltinOptions_MulOptions,
1512                                           BuiltinOptions_PadOptions,
1513                                           BuiltinOptions_GatherOptions,
1514                                           BuiltinOptions_BatchToSpaceNDOptions,
1515                                           BuiltinOptions_SpaceToBatchNDOptions,
1516                                           BuiltinOptions_TransposeOptions,
1517                                           BuiltinOptions_ReducerOptions,
1518                                           BuiltinOptions_SubOptions,
1519                                           BuiltinOptions_DivOptions,
1520                                           BuiltinOptions_SqueezeOptions,
1521                                           BuiltinOptions_SequenceRNNOptions,
1522                                           BuiltinOptions_StridedSliceOptions,
1523                                           BuiltinOptions_ExpOptions,
1524                                           BuiltinOptions_TopKV2Options,
1525                                           BuiltinOptions_SplitOptions,
1526                                           BuiltinOptions_LogSoftmaxOptions,
1527                                           BuiltinOptions_CastOptions,
1528                                           BuiltinOptions_DequantizeOptions,
1529                                           BuiltinOptions_MaximumMinimumOptions,
1530                                           BuiltinOptions_ArgMaxOptions,
1531                                           BuiltinOptions_LessOptions,
1532                                           BuiltinOptions_NegOptions,
1533                                           BuiltinOptions_PadV2Options,
1534                                           BuiltinOptions_GreaterOptions,
1535                                           BuiltinOptions_GreaterEqualOptions,
1536                                           BuiltinOptions_LessEqualOptions,
1537                                           BuiltinOptions_SelectOptions,
1538                                           BuiltinOptions_SliceOptions,
1539                                           BuiltinOptions_TransposeConvOptions,
1540                                           BuiltinOptions_SparseToDenseOptions,
1541                                           BuiltinOptions_TileOptions,
1542                                           BuiltinOptions_ExpandDimsOptions,
1543                                           BuiltinOptions_EqualOptions,
1544                                           BuiltinOptions_NotEqualOptions,
1545                                           BuiltinOptions_ShapeOptions,
1546                                           BuiltinOptions_PowOptions,
1547                                           BuiltinOptions_ArgMinOptions,
1548                                           BuiltinOptions_FakeQuantOptions,
1549                                           BuiltinOptions_PackOptions,
1550                                           BuiltinOptions_LogicalOrOptions,
1551                                           BuiltinOptions_OneHotOptions,
1552                                           BuiltinOptions_LogicalAndOptions,
1553                                           BuiltinOptions_LogicalNotOptions,
1554                                           BuiltinOptions_UnpackOptions,
1555                                           BuiltinOptions_FloorDivOptions,
1556                                           BuiltinOptions_SquareOptions,
1557                                           BuiltinOptions_ZerosLikeOptions,
1558                                           BuiltinOptions_FillOptions,
1559                                           BuiltinOptions_BidirectionalSequenceLSTMOptions,
1560                                           BuiltinOptions_BidirectionalSequenceRNNOptions,
1561                                           BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1562                                           BuiltinOptions_FloorModOptions,
1563                                           BuiltinOptions_RangeOptions,
1564                                           BuiltinOptions_ResizeNearestNeighborOptions,
1565                                           BuiltinOptions_LeakyReluOptions,
1566                                           BuiltinOptions_SquaredDifferenceOptions,
1567                                           BuiltinOptions_MirrorPadOptions,
1568                                           BuiltinOptions_AbsOptions,
1569                                           BuiltinOptions_SplitVOptions,
1570                                           BuiltinOptions_UniqueOptions,
1571                                           BuiltinOptions_ReverseV2Options,
1572                                           BuiltinOptions_AddNOptions,
1573                                           BuiltinOptions_GatherNdOptions,
1574                                           BuiltinOptions_CosOptions,
1575                                           BuiltinOptions_WhereOptions,
1576                                           BuiltinOptions_RankOptions,
1577                                           BuiltinOptions_ReverseSequenceOptions,
1578                                           BuiltinOptions_MatrixDiagOptions,
1579                                           BuiltinOptions_QuantizeOptions,
1580                                           BuiltinOptions_MatrixSetDiagOptions,
1581                                           BuiltinOptions_HardSwishOptions,
1582                                           BuiltinOptions_IfOptions,
1583                                           BuiltinOptions_WhileOptions,
1584                                           BuiltinOptions_DepthToSpaceOptions,
1585                                           BuiltinOptions_NonMaxSuppressionV4Options,
1586                                           BuiltinOptions_NonMaxSuppressionV5Options,
1587                                           BuiltinOptions_ScatterNdOptions,
1588                                           BuiltinOptions_SelectV2Options,
1589                                           BuiltinOptions_DensifyOptions,
1590                                           BuiltinOptions_SegmentSumOptions,
1591                                           BuiltinOptions_BatchMatMulOptions,
1592                                           BuiltinOptions_CumsumOptions,
1593                                           BuiltinOptions_CallOnceOptions,
1594                                           BuiltinOptions_BroadcastToOptions,
1595                                           BuiltinOptions_Rfft2dOptions,
1596                                           BuiltinOptions_Conv3DOptions,
1597                                           BuiltinOptions_HashtableOptions,
1598                                           BuiltinOptions_HashtableFindOptions,
1599                                           BuiltinOptions_HashtableImportOptions,
1600                                           BuiltinOptions_HashtableSizeOptions,
1601                                           BuiltinOptions_VarHandleOptions,
1602                                           BuiltinOptions_ReadVariableOptions,
1603                                           BuiltinOptions_AssignVariableOptions,
1604                                           BuiltinOptions_RandomOptions,
1605                                           BuiltinOptions_BCQGatherOptions,
1606                                           BuiltinOptions_BCQFullyConnectedOptions,
1607                                           BuiltinOptions_InstanceNormOptions};
1608   return values;
1609 }
1610
1611 inline const char *const *EnumNamesBuiltinOptions()
1612 {
1613   static const char *const names[256] = {"NONE",
1614                                          "Conv2DOptions",
1615                                          "DepthwiseConv2DOptions",
1616                                          "ConcatEmbeddingsOptions",
1617                                          "LSHProjectionOptions",
1618                                          "Pool2DOptions",
1619                                          "SVDFOptions",
1620                                          "RNNOptions",
1621                                          "FullyConnectedOptions",
1622                                          "SoftmaxOptions",
1623                                          "ConcatenationOptions",
1624                                          "AddOptions",
1625                                          "L2NormOptions",
1626                                          "LocalResponseNormalizationOptions",
1627                                          "LSTMOptions",
1628                                          "ResizeBilinearOptions",
1629                                          "CallOptions",
1630                                          "ReshapeOptions",
1631                                          "SkipGramOptions",
1632                                          "SpaceToDepthOptions",
1633                                          "EmbeddingLookupSparseOptions",
1634                                          "MulOptions",
1635                                          "PadOptions",
1636                                          "GatherOptions",
1637                                          "BatchToSpaceNDOptions",
1638                                          "SpaceToBatchNDOptions",
1639                                          "TransposeOptions",
1640                                          "ReducerOptions",
1641                                          "SubOptions",
1642                                          "DivOptions",
1643                                          "SqueezeOptions",
1644                                          "SequenceRNNOptions",
1645                                          "StridedSliceOptions",
1646                                          "ExpOptions",
1647                                          "TopKV2Options",
1648                                          "SplitOptions",
1649                                          "LogSoftmaxOptions",
1650                                          "CastOptions",
1651                                          "DequantizeOptions",
1652                                          "MaximumMinimumOptions",
1653                                          "ArgMaxOptions",
1654                                          "LessOptions",
1655                                          "NegOptions",
1656                                          "PadV2Options",
1657                                          "GreaterOptions",
1658                                          "GreaterEqualOptions",
1659                                          "LessEqualOptions",
1660                                          "SelectOptions",
1661                                          "SliceOptions",
1662                                          "TransposeConvOptions",
1663                                          "SparseToDenseOptions",
1664                                          "TileOptions",
1665                                          "ExpandDimsOptions",
1666                                          "EqualOptions",
1667                                          "NotEqualOptions",
1668                                          "ShapeOptions",
1669                                          "PowOptions",
1670                                          "ArgMinOptions",
1671                                          "FakeQuantOptions",
1672                                          "PackOptions",
1673                                          "LogicalOrOptions",
1674                                          "OneHotOptions",
1675                                          "LogicalAndOptions",
1676                                          "LogicalNotOptions",
1677                                          "UnpackOptions",
1678                                          "FloorDivOptions",
1679                                          "SquareOptions",
1680                                          "ZerosLikeOptions",
1681                                          "FillOptions",
1682                                          "BidirectionalSequenceLSTMOptions",
1683                                          "BidirectionalSequenceRNNOptions",
1684                                          "UnidirectionalSequenceLSTMOptions",
1685                                          "FloorModOptions",
1686                                          "RangeOptions",
1687                                          "ResizeNearestNeighborOptions",
1688                                          "LeakyReluOptions",
1689                                          "SquaredDifferenceOptions",
1690                                          "MirrorPadOptions",
1691                                          "AbsOptions",
1692                                          "SplitVOptions",
1693                                          "UniqueOptions",
1694                                          "ReverseV2Options",
1695                                          "AddNOptions",
1696                                          "GatherNdOptions",
1697                                          "CosOptions",
1698                                          "WhereOptions",
1699                                          "RankOptions",
1700                                          "ReverseSequenceOptions",
1701                                          "MatrixDiagOptions",
1702                                          "QuantizeOptions",
1703                                          "MatrixSetDiagOptions",
1704                                          "HardSwishOptions",
1705                                          "IfOptions",
1706                                          "WhileOptions",
1707                                          "DepthToSpaceOptions",
1708                                          "NonMaxSuppressionV4Options",
1709                                          "NonMaxSuppressionV5Options",
1710                                          "ScatterNdOptions",
1711                                          "SelectV2Options",
1712                                          "DensifyOptions",
1713                                          "SegmentSumOptions",
1714                                          "BatchMatMulOptions",
1715                                          "CumsumOptions",
1716                                          "CallOnceOptions",
1717                                          "BroadcastToOptions",
1718                                          "Rfft2dOptions",
1719                                          "Conv3DOptions",
1720                                          "HashtableOptions",
1721                                          "HashtableFindOptions",
1722                                          "HashtableImportOptions",
1723                                          "HashtableSizeOptions",
1724                                          "VarHandleOptions",
1725                                          "ReadVariableOptions",
1726                                          "AssignVariableOptions",
1727                                          "RandomOptions",
1728                                          "",
1729                                          "",
1730                                          "",
1731                                          "",
1732                                          "",
1733                                          "",
1734                                          "",
1735                                          "",
1736                                          "",
1737                                          "",
1738                                          "",
1739                                          "",
1740                                          "",
1741                                          "",
1742                                          "",
1743                                          "",
1744                                          "",
1745                                          "",
1746                                          "",
1747                                          "",
1748                                          "",
1749                                          "",
1750                                          "",
1751                                          "",
1752                                          "",
1753                                          "",
1754                                          "",
1755                                          "",
1756                                          "",
1757                                          "",
1758                                          "",
1759                                          "",
1760                                          "",
1761                                          "",
1762                                          "",
1763                                          "",
1764                                          "",
1765                                          "",
1766                                          "",
1767                                          "",
1768                                          "",
1769                                          "",
1770                                          "",
1771                                          "",
1772                                          "",
1773                                          "",
1774                                          "",
1775                                          "",
1776                                          "",
1777                                          "",
1778                                          "",
1779                                          "",
1780                                          "",
1781                                          "",
1782                                          "",
1783                                          "",
1784                                          "",
1785                                          "",
1786                                          "",
1787                                          "",
1788                                          "",
1789                                          "",
1790                                          "",
1791                                          "",
1792                                          "",
1793                                          "",
1794                                          "",
1795                                          "",
1796                                          "",
1797                                          "",
1798                                          "",
1799                                          "",
1800                                          "",
1801                                          "",
1802                                          "",
1803                                          "",
1804                                          "",
1805                                          "",
1806                                          "",
1807                                          "",
1808                                          "",
1809                                          "",
1810                                          "",
1811                                          "",
1812                                          "",
1813                                          "",
1814                                          "",
1815                                          "",
1816                                          "",
1817                                          "",
1818                                          "",
1819                                          "",
1820                                          "",
1821                                          "",
1822                                          "",
1823                                          "",
1824                                          "",
1825                                          "",
1826                                          "",
1827                                          "",
1828                                          "",
1829                                          "",
1830                                          "",
1831                                          "",
1832                                          "",
1833                                          "",
1834                                          "",
1835                                          "",
1836                                          "",
1837                                          "",
1838                                          "",
1839                                          "",
1840                                          "",
1841                                          "",
1842                                          "",
1843                                          "",
1844                                          "",
1845                                          "",
1846                                          "",
1847                                          "",
1848                                          "",
1849                                          "",
1850                                          "",
1851                                          "",
1852                                          "",
1853                                          "",
1854                                          "",
1855                                          "",
1856                                          "",
1857                                          "",
1858                                          "",
1859                                          "",
1860                                          "",
1861                                          "",
1862                                          "",
1863                                          "",
1864                                          "",
1865                                          "BCQGatherOptions",
1866                                          "BCQFullyConnectedOptions",
1867                                          "InstanceNormOptions",
1868                                          nullptr};
1869   return names;
1870 }
1871
1872 inline const char *EnumNameBuiltinOptions(BuiltinOptions e)
1873 {
1874   if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_InstanceNormOptions))
1875     return "";
1876   const size_t index = static_cast<size_t>(e);
1877   return EnumNamesBuiltinOptions()[index];
1878 }
1879
1880 template <typename T> struct BuiltinOptionsTraits
1881 {
1882   static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1883 };
1884
1885 template <> struct BuiltinOptionsTraits<circle::Conv2DOptions>
1886 {
1887   static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1888 };
1889
1890 template <> struct BuiltinOptionsTraits<circle::DepthwiseConv2DOptions>
1891 {
1892   static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1893 };
1894
1895 template <> struct BuiltinOptionsTraits<circle::ConcatEmbeddingsOptions>
1896 {
1897   static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1898 };
1899
1900 template <> struct BuiltinOptionsTraits<circle::LSHProjectionOptions>
1901 {
1902   static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1903 };
1904
1905 template <> struct BuiltinOptionsTraits<circle::Pool2DOptions>
1906 {
1907   static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1908 };
1909
1910 template <> struct BuiltinOptionsTraits<circle::SVDFOptions>
1911 {
1912   static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1913 };
1914
1915 template <> struct BuiltinOptionsTraits<circle::RNNOptions>
1916 {
1917   static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1918 };
1919
1920 template <> struct BuiltinOptionsTraits<circle::FullyConnectedOptions>
1921 {
1922   static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1923 };
1924
1925 template <> struct BuiltinOptionsTraits<circle::SoftmaxOptions>
1926 {
1927   static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1928 };
1929
1930 template <> struct BuiltinOptionsTraits<circle::ConcatenationOptions>
1931 {
1932   static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1933 };
1934
1935 template <> struct BuiltinOptionsTraits<circle::AddOptions>
1936 {
1937   static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1938 };
1939
1940 template <> struct BuiltinOptionsTraits<circle::L2NormOptions>
1941 {
1942   static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1943 };
1944
1945 template <> struct BuiltinOptionsTraits<circle::LocalResponseNormalizationOptions>
1946 {
1947   static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1948 };
1949
1950 template <> struct BuiltinOptionsTraits<circle::LSTMOptions>
1951 {
1952   static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1953 };
1954
1955 template <> struct BuiltinOptionsTraits<circle::ResizeBilinearOptions>
1956 {
1957   static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1958 };
1959
1960 template <> struct BuiltinOptionsTraits<circle::CallOptions>
1961 {
1962   static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1963 };
1964
1965 template <> struct BuiltinOptionsTraits<circle::ReshapeOptions>
1966 {
1967   static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1968 };
1969
1970 template <> struct BuiltinOptionsTraits<circle::SkipGramOptions>
1971 {
1972   static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1973 };
1974
1975 template <> struct BuiltinOptionsTraits<circle::SpaceToDepthOptions>
1976 {
1977   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1978 };
1979
1980 template <> struct BuiltinOptionsTraits<circle::EmbeddingLookupSparseOptions>
1981 {
1982   static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1983 };
1984
1985 template <> struct BuiltinOptionsTraits<circle::MulOptions>
1986 {
1987   static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1988 };
1989
1990 template <> struct BuiltinOptionsTraits<circle::PadOptions>
1991 {
1992   static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1993 };
1994
1995 template <> struct BuiltinOptionsTraits<circle::GatherOptions>
1996 {
1997   static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1998 };
1999
2000 template <> struct BuiltinOptionsTraits<circle::BatchToSpaceNDOptions>
2001 {
2002   static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
2003 };
2004
2005 template <> struct BuiltinOptionsTraits<circle::SpaceToBatchNDOptions>
2006 {
2007   static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
2008 };
2009
2010 template <> struct BuiltinOptionsTraits<circle::TransposeOptions>
2011 {
2012   static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
2013 };
2014
2015 template <> struct BuiltinOptionsTraits<circle::ReducerOptions>
2016 {
2017   static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
2018 };
2019
2020 template <> struct BuiltinOptionsTraits<circle::SubOptions>
2021 {
2022   static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
2023 };
2024
2025 template <> struct BuiltinOptionsTraits<circle::DivOptions>
2026 {
2027   static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
2028 };
2029
2030 template <> struct BuiltinOptionsTraits<circle::SqueezeOptions>
2031 {
2032   static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
2033 };
2034
2035 template <> struct BuiltinOptionsTraits<circle::SequenceRNNOptions>
2036 {
2037   static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
2038 };
2039
2040 template <> struct BuiltinOptionsTraits<circle::StridedSliceOptions>
2041 {
2042   static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
2043 };
2044
2045 template <> struct BuiltinOptionsTraits<circle::ExpOptions>
2046 {
2047   static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
2048 };
2049
2050 template <> struct BuiltinOptionsTraits<circle::TopKV2Options>
2051 {
2052   static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
2053 };
2054
2055 template <> struct BuiltinOptionsTraits<circle::SplitOptions>
2056 {
2057   static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
2058 };
2059
2060 template <> struct BuiltinOptionsTraits<circle::LogSoftmaxOptions>
2061 {
2062   static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
2063 };
2064
2065 template <> struct BuiltinOptionsTraits<circle::CastOptions>
2066 {
2067   static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
2068 };
2069
2070 template <> struct BuiltinOptionsTraits<circle::DequantizeOptions>
2071 {
2072   static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
2073 };
2074
2075 template <> struct BuiltinOptionsTraits<circle::MaximumMinimumOptions>
2076 {
2077   static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
2078 };
2079
2080 template <> struct BuiltinOptionsTraits<circle::ArgMaxOptions>
2081 {
2082   static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
2083 };
2084
2085 template <> struct BuiltinOptionsTraits<circle::LessOptions>
2086 {
2087   static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
2088 };
2089
2090 template <> struct BuiltinOptionsTraits<circle::NegOptions>
2091 {
2092   static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
2093 };
2094
2095 template <> struct BuiltinOptionsTraits<circle::PadV2Options>
2096 {
2097   static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
2098 };
2099
2100 template <> struct BuiltinOptionsTraits<circle::GreaterOptions>
2101 {
2102   static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
2103 };
2104
2105 template <> struct BuiltinOptionsTraits<circle::GreaterEqualOptions>
2106 {
2107   static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
2108 };
2109
2110 template <> struct BuiltinOptionsTraits<circle::LessEqualOptions>
2111 {
2112   static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
2113 };
2114
2115 template <> struct BuiltinOptionsTraits<circle::SelectOptions>
2116 {
2117   static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
2118 };
2119
2120 template <> struct BuiltinOptionsTraits<circle::SliceOptions>
2121 {
2122   static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
2123 };
2124
2125 template <> struct BuiltinOptionsTraits<circle::TransposeConvOptions>
2126 {
2127   static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
2128 };
2129
2130 template <> struct BuiltinOptionsTraits<circle::SparseToDenseOptions>
2131 {
2132   static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
2133 };
2134
2135 template <> struct BuiltinOptionsTraits<circle::TileOptions>
2136 {
2137   static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
2138 };
2139
2140 template <> struct BuiltinOptionsTraits<circle::ExpandDimsOptions>
2141 {
2142   static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
2143 };
2144
2145 template <> struct BuiltinOptionsTraits<circle::EqualOptions>
2146 {
2147   static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
2148 };
2149
2150 template <> struct BuiltinOptionsTraits<circle::NotEqualOptions>
2151 {
2152   static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
2153 };
2154
2155 template <> struct BuiltinOptionsTraits<circle::ShapeOptions>
2156 {
2157   static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
2158 };
2159
2160 template <> struct BuiltinOptionsTraits<circle::PowOptions>
2161 {
2162   static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
2163 };
2164
2165 template <> struct BuiltinOptionsTraits<circle::ArgMinOptions>
2166 {
2167   static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
2168 };
2169
2170 template <> struct BuiltinOptionsTraits<circle::FakeQuantOptions>
2171 {
2172   static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
2173 };
2174
2175 template <> struct BuiltinOptionsTraits<circle::PackOptions>
2176 {
2177   static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
2178 };
2179
2180 template <> struct BuiltinOptionsTraits<circle::LogicalOrOptions>
2181 {
2182   static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
2183 };
2184
2185 template <> struct BuiltinOptionsTraits<circle::OneHotOptions>
2186 {
2187   static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
2188 };
2189
2190 template <> struct BuiltinOptionsTraits<circle::LogicalAndOptions>
2191 {
2192   static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
2193 };
2194
2195 template <> struct BuiltinOptionsTraits<circle::LogicalNotOptions>
2196 {
2197   static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
2198 };
2199
2200 template <> struct BuiltinOptionsTraits<circle::UnpackOptions>
2201 {
2202   static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
2203 };
2204
2205 template <> struct BuiltinOptionsTraits<circle::FloorDivOptions>
2206 {
2207   static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
2208 };
2209
2210 template <> struct BuiltinOptionsTraits<circle::SquareOptions>
2211 {
2212   static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
2213 };
2214
2215 template <> struct BuiltinOptionsTraits<circle::ZerosLikeOptions>
2216 {
2217   static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
2218 };
2219
2220 template <> struct BuiltinOptionsTraits<circle::FillOptions>
2221 {
2222   static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
2223 };
2224
2225 template <> struct BuiltinOptionsTraits<circle::BidirectionalSequenceLSTMOptions>
2226 {
2227   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
2228 };
2229
2230 template <> struct BuiltinOptionsTraits<circle::BidirectionalSequenceRNNOptions>
2231 {
2232   static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
2233 };
2234
2235 template <> struct BuiltinOptionsTraits<circle::UnidirectionalSequenceLSTMOptions>
2236 {
2237   static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
2238 };
2239
2240 template <> struct BuiltinOptionsTraits<circle::FloorModOptions>
2241 {
2242   static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
2243 };
2244
2245 template <> struct BuiltinOptionsTraits<circle::RangeOptions>
2246 {
2247   static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
2248 };
2249
2250 template <> struct BuiltinOptionsTraits<circle::ResizeNearestNeighborOptions>
2251 {
2252   static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
2253 };
2254
2255 template <> struct BuiltinOptionsTraits<circle::LeakyReluOptions>
2256 {
2257   static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
2258 };
2259
2260 template <> struct BuiltinOptionsTraits<circle::SquaredDifferenceOptions>
2261 {
2262   static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
2263 };
2264
2265 template <> struct BuiltinOptionsTraits<circle::MirrorPadOptions>
2266 {
2267   static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
2268 };
2269
2270 template <> struct BuiltinOptionsTraits<circle::AbsOptions>
2271 {
2272   static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
2273 };
2274
2275 template <> struct BuiltinOptionsTraits<circle::SplitVOptions>
2276 {
2277   static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
2278 };
2279
2280 template <> struct BuiltinOptionsTraits<circle::UniqueOptions>
2281 {
2282   static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
2283 };
2284
2285 template <> struct BuiltinOptionsTraits<circle::ReverseV2Options>
2286 {
2287   static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
2288 };
2289
2290 template <> struct BuiltinOptionsTraits<circle::AddNOptions>
2291 {
2292   static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
2293 };
2294
2295 template <> struct BuiltinOptionsTraits<circle::GatherNdOptions>
2296 {
2297   static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
2298 };
2299
2300 template <> struct BuiltinOptionsTraits<circle::CosOptions>
2301 {
2302   static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
2303 };
2304
2305 template <> struct BuiltinOptionsTraits<circle::WhereOptions>
2306 {
2307   static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
2308 };
2309
2310 template <> struct BuiltinOptionsTraits<circle::RankOptions>
2311 {
2312   static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
2313 };
2314
2315 template <> struct BuiltinOptionsTraits<circle::ReverseSequenceOptions>
2316 {
2317   static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
2318 };
2319
2320 template <> struct BuiltinOptionsTraits<circle::MatrixDiagOptions>
2321 {
2322   static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
2323 };
2324
2325 template <> struct BuiltinOptionsTraits<circle::QuantizeOptions>
2326 {
2327   static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
2328 };
2329
2330 template <> struct BuiltinOptionsTraits<circle::MatrixSetDiagOptions>
2331 {
2332   static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
2333 };
2334
2335 template <> struct BuiltinOptionsTraits<circle::HardSwishOptions>
2336 {
2337   static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
2338 };
2339
2340 template <> struct BuiltinOptionsTraits<circle::IfOptions>
2341 {
2342   static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
2343 };
2344
2345 template <> struct BuiltinOptionsTraits<circle::WhileOptions>
2346 {
2347   static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
2348 };
2349
2350 template <> struct BuiltinOptionsTraits<circle::DepthToSpaceOptions>
2351 {
2352   static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
2353 };
2354
2355 template <> struct BuiltinOptionsTraits<circle::NonMaxSuppressionV4Options>
2356 {
2357   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
2358 };
2359
2360 template <> struct BuiltinOptionsTraits<circle::NonMaxSuppressionV5Options>
2361 {
2362   static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
2363 };
2364
2365 template <> struct BuiltinOptionsTraits<circle::ScatterNdOptions>
2366 {
2367   static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
2368 };
2369
2370 template <> struct BuiltinOptionsTraits<circle::SelectV2Options>
2371 {
2372   static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
2373 };
2374
2375 template <> struct BuiltinOptionsTraits<circle::DensifyOptions>
2376 {
2377   static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
2378 };
2379
2380 template <> struct BuiltinOptionsTraits<circle::SegmentSumOptions>
2381 {
2382   static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
2383 };
2384
2385 template <> struct BuiltinOptionsTraits<circle::BatchMatMulOptions>
2386 {
2387   static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
2388 };
2389
2390 template <> struct BuiltinOptionsTraits<circle::CumsumOptions>
2391 {
2392   static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
2393 };
2394
2395 template <> struct BuiltinOptionsTraits<circle::CallOnceOptions>
2396 {
2397   static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
2398 };
2399
2400 template <> struct BuiltinOptionsTraits<circle::BroadcastToOptions>
2401 {
2402   static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
2403 };
2404
2405 template <> struct BuiltinOptionsTraits<circle::Rfft2dOptions>
2406 {
2407   static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
2408 };
2409
2410 template <> struct BuiltinOptionsTraits<circle::Conv3DOptions>
2411 {
2412   static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
2413 };
2414
2415 template <> struct BuiltinOptionsTraits<circle::HashtableOptions>
2416 {
2417   static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
2418 };
2419
2420 template <> struct BuiltinOptionsTraits<circle::HashtableFindOptions>
2421 {
2422   static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
2423 };
2424
2425 template <> struct BuiltinOptionsTraits<circle::HashtableImportOptions>
2426 {
2427   static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
2428 };
2429
2430 template <> struct BuiltinOptionsTraits<circle::HashtableSizeOptions>
2431 {
2432   static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
2433 };
2434
2435 template <> struct BuiltinOptionsTraits<circle::VarHandleOptions>
2436 {
2437   static const BuiltinOptions enum_value = BuiltinOptions_VarHandleOptions;
2438 };
2439
2440 template <> struct BuiltinOptionsTraits<circle::ReadVariableOptions>
2441 {
2442   static const BuiltinOptions enum_value = BuiltinOptions_ReadVariableOptions;
2443 };
2444
2445 template <> struct BuiltinOptionsTraits<circle::AssignVariableOptions>
2446 {
2447   static const BuiltinOptions enum_value = BuiltinOptions_AssignVariableOptions;
2448 };
2449
2450 template <> struct BuiltinOptionsTraits<circle::RandomOptions>
2451 {
2452   static const BuiltinOptions enum_value = BuiltinOptions_RandomOptions;
2453 };
2454
2455 template <> struct BuiltinOptionsTraits<circle::BCQGatherOptions>
2456 {
2457   static const BuiltinOptions enum_value = BuiltinOptions_BCQGatherOptions;
2458 };
2459
2460 template <> struct BuiltinOptionsTraits<circle::BCQFullyConnectedOptions>
2461 {
2462   static const BuiltinOptions enum_value = BuiltinOptions_BCQFullyConnectedOptions;
2463 };
2464
2465 template <> struct BuiltinOptionsTraits<circle::InstanceNormOptions>
2466 {
2467   static const BuiltinOptions enum_value = BuiltinOptions_InstanceNormOptions;
2468 };
2469
2470 struct BuiltinOptionsUnion
2471 {
2472   BuiltinOptions type;
2473   void *value;
2474
2475   BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
2476   BuiltinOptionsUnion(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT : type(BuiltinOptions_NONE),
2477                                                                       value(nullptr)
2478   {
2479     std::swap(type, u.type);
2480     std::swap(value, u.value);
2481   }
2482   BuiltinOptionsUnion(const BuiltinOptionsUnion &);
2483   BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u)
2484   {
2485     BuiltinOptionsUnion t(u);
2486     std::swap(type, t.type);
2487     std::swap(value, t.value);
2488     return *this;
2489   }
2490   BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
2491   {
2492     std::swap(type, u.type);
2493     std::swap(value, u.value);
2494     return *this;
2495   }
2496   ~BuiltinOptionsUnion() { Reset(); }
2497
2498   void Reset();
2499
2500 #ifndef FLATBUFFERS_CPP98_STL
2501   template <typename T> void Set(T &&val)
2502   {
2503     using RT = typename std::remove_reference<T>::type;
2504     Reset();
2505     type = BuiltinOptionsTraits<typename RT::TableType>::enum_value;
2506     if (type != BuiltinOptions_NONE)
2507     {
2508       value = new RT(std::forward<T>(val));
2509     }
2510   }
2511 #endif // FLATBUFFERS_CPP98_STL
2512
2513   static void *UnPack(const void *obj, BuiltinOptions type,
2514                       const flatbuffers::resolver_function_t *resolver);
2515   flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb,
2516                                  const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
2517
2518   circle::Conv2DOptionsT *AsConv2DOptions()
2519   {
2520     return type == BuiltinOptions_Conv2DOptions ? reinterpret_cast<circle::Conv2DOptionsT *>(value)
2521                                                 : nullptr;
2522   }
2523   const circle::Conv2DOptionsT *AsConv2DOptions() const
2524   {
2525     return type == BuiltinOptions_Conv2DOptions
2526              ? reinterpret_cast<const circle::Conv2DOptionsT *>(value)
2527              : nullptr;
2528   }
2529   circle::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions()
2530   {
2531     return type == BuiltinOptions_DepthwiseConv2DOptions
2532              ? reinterpret_cast<circle::DepthwiseConv2DOptionsT *>(value)
2533              : nullptr;
2534   }
2535   const circle::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const
2536   {
2537     return type == BuiltinOptions_DepthwiseConv2DOptions
2538              ? reinterpret_cast<const circle::DepthwiseConv2DOptionsT *>(value)
2539              : nullptr;
2540   }
2541   circle::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions()
2542   {
2543     return type == BuiltinOptions_ConcatEmbeddingsOptions
2544              ? reinterpret_cast<circle::ConcatEmbeddingsOptionsT *>(value)
2545              : nullptr;
2546   }
2547   const circle::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const
2548   {
2549     return type == BuiltinOptions_ConcatEmbeddingsOptions
2550              ? reinterpret_cast<const circle::ConcatEmbeddingsOptionsT *>(value)
2551              : nullptr;
2552   }
2553   circle::LSHProjectionOptionsT *AsLSHProjectionOptions()
2554   {
2555     return type == BuiltinOptions_LSHProjectionOptions
2556              ? reinterpret_cast<circle::LSHProjectionOptionsT *>(value)
2557              : nullptr;
2558   }
2559   const circle::LSHProjectionOptionsT *AsLSHProjectionOptions() const
2560   {
2561     return type == BuiltinOptions_LSHProjectionOptions
2562              ? reinterpret_cast<const circle::LSHProjectionOptionsT *>(value)
2563              : nullptr;
2564   }
2565   circle::Pool2DOptionsT *AsPool2DOptions()
2566   {
2567     return type == BuiltinOptions_Pool2DOptions ? reinterpret_cast<circle::Pool2DOptionsT *>(value)
2568                                                 : nullptr;
2569   }
2570   const circle::Pool2DOptionsT *AsPool2DOptions() const
2571   {
2572     return type == BuiltinOptions_Pool2DOptions
2573              ? reinterpret_cast<const circle::Pool2DOptionsT *>(value)
2574              : nullptr;
2575   }
2576   circle::SVDFOptionsT *AsSVDFOptions()
2577   {
2578     return type == BuiltinOptions_SVDFOptions ? reinterpret_cast<circle::SVDFOptionsT *>(value)
2579                                               : nullptr;
2580   }
2581   const circle::SVDFOptionsT *AsSVDFOptions() const
2582   {
2583     return type == BuiltinOptions_SVDFOptions
2584              ? reinterpret_cast<const circle::SVDFOptionsT *>(value)
2585              : nullptr;
2586   }
2587   circle::RNNOptionsT *AsRNNOptions()
2588   {
2589     return type == BuiltinOptions_RNNOptions ? reinterpret_cast<circle::RNNOptionsT *>(value)
2590                                              : nullptr;
2591   }
2592   const circle::RNNOptionsT *AsRNNOptions() const
2593   {
2594     return type == BuiltinOptions_RNNOptions ? reinterpret_cast<const circle::RNNOptionsT *>(value)
2595                                              : nullptr;
2596   }
2597   circle::FullyConnectedOptionsT *AsFullyConnectedOptions()
2598   {
2599     return type == BuiltinOptions_FullyConnectedOptions
2600              ? reinterpret_cast<circle::FullyConnectedOptionsT *>(value)
2601              : nullptr;
2602   }
2603   const circle::FullyConnectedOptionsT *AsFullyConnectedOptions() const
2604   {
2605     return type == BuiltinOptions_FullyConnectedOptions
2606              ? reinterpret_cast<const circle::FullyConnectedOptionsT *>(value)
2607              : nullptr;
2608   }
2609   circle::SoftmaxOptionsT *AsSoftmaxOptions()
2610   {
2611     return type == BuiltinOptions_SoftmaxOptions
2612              ? reinterpret_cast<circle::SoftmaxOptionsT *>(value)
2613              : nullptr;
2614   }
2615   const circle::SoftmaxOptionsT *AsSoftmaxOptions() const
2616   {
2617     return type == BuiltinOptions_SoftmaxOptions
2618              ? reinterpret_cast<const circle::SoftmaxOptionsT *>(value)
2619              : nullptr;
2620   }
2621   circle::ConcatenationOptionsT *AsConcatenationOptions()
2622   {
2623     return type == BuiltinOptions_ConcatenationOptions
2624              ? reinterpret_cast<circle::ConcatenationOptionsT *>(value)
2625              : nullptr;
2626   }
2627   const circle::ConcatenationOptionsT *AsConcatenationOptions() const
2628   {
2629     return type == BuiltinOptions_ConcatenationOptions
2630              ? reinterpret_cast<const circle::ConcatenationOptionsT *>(value)
2631              : nullptr;
2632   }
2633   circle::AddOptionsT *AsAddOptions()
2634   {
2635     return type == BuiltinOptions_AddOptions ? reinterpret_cast<circle::AddOptionsT *>(value)
2636                                              : nullptr;
2637   }
2638   const circle::AddOptionsT *AsAddOptions() const
2639   {
2640     return type == BuiltinOptions_AddOptions ? reinterpret_cast<const circle::AddOptionsT *>(value)
2641                                              : nullptr;
2642   }
2643   circle::L2NormOptionsT *AsL2NormOptions()
2644   {
2645     return type == BuiltinOptions_L2NormOptions ? reinterpret_cast<circle::L2NormOptionsT *>(value)
2646                                                 : nullptr;
2647   }
2648   const circle::L2NormOptionsT *AsL2NormOptions() const
2649   {
2650     return type == BuiltinOptions_L2NormOptions
2651              ? reinterpret_cast<const circle::L2NormOptionsT *>(value)
2652              : nullptr;
2653   }
2654   circle::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions()
2655   {
2656     return type == BuiltinOptions_LocalResponseNormalizationOptions
2657              ? reinterpret_cast<circle::LocalResponseNormalizationOptionsT *>(value)
2658              : nullptr;
2659   }
2660   const circle::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const
2661   {
2662     return type == BuiltinOptions_LocalResponseNormalizationOptions
2663              ? reinterpret_cast<const circle::LocalResponseNormalizationOptionsT *>(value)
2664              : nullptr;
2665   }
2666   circle::LSTMOptionsT *AsLSTMOptions()
2667   {
2668     return type == BuiltinOptions_LSTMOptions ? reinterpret_cast<circle::LSTMOptionsT *>(value)
2669                                               : nullptr;
2670   }
2671   const circle::LSTMOptionsT *AsLSTMOptions() const
2672   {
2673     return type == BuiltinOptions_LSTMOptions
2674              ? reinterpret_cast<const circle::LSTMOptionsT *>(value)
2675              : nullptr;
2676   }
2677   circle::ResizeBilinearOptionsT *AsResizeBilinearOptions()
2678   {
2679     return type == BuiltinOptions_ResizeBilinearOptions
2680              ? reinterpret_cast<circle::ResizeBilinearOptionsT *>(value)
2681              : nullptr;
2682   }
2683   const circle::ResizeBilinearOptionsT *AsResizeBilinearOptions() const
2684   {
2685     return type == BuiltinOptions_ResizeBilinearOptions
2686              ? reinterpret_cast<const circle::ResizeBilinearOptionsT *>(value)
2687              : nullptr;
2688   }
2689   circle::CallOptionsT *AsCallOptions()
2690   {
2691     return type == BuiltinOptions_CallOptions ? reinterpret_cast<circle::CallOptionsT *>(value)
2692                                               : nullptr;
2693   }
2694   const circle::CallOptionsT *AsCallOptions() const
2695   {
2696     return type == BuiltinOptions_CallOptions
2697              ? reinterpret_cast<const circle::CallOptionsT *>(value)
2698              : nullptr;
2699   }
2700   circle::ReshapeOptionsT *AsReshapeOptions()
2701   {
2702     return type == BuiltinOptions_ReshapeOptions
2703              ? reinterpret_cast<circle::ReshapeOptionsT *>(value)
2704              : nullptr;
2705   }
2706   const circle::ReshapeOptionsT *AsReshapeOptions() const
2707   {
2708     return type == BuiltinOptions_ReshapeOptions
2709              ? reinterpret_cast<const circle::ReshapeOptionsT *>(value)
2710              : nullptr;
2711   }
2712   circle::SkipGramOptionsT *AsSkipGramOptions()
2713   {
2714     return type == BuiltinOptions_SkipGramOptions
2715              ? reinterpret_cast<circle::SkipGramOptionsT *>(value)
2716              : nullptr;
2717   }
2718   const circle::SkipGramOptionsT *AsSkipGramOptions() const
2719   {
2720     return type == BuiltinOptions_SkipGramOptions
2721              ? reinterpret_cast<const circle::SkipGramOptionsT *>(value)
2722              : nullptr;
2723   }
2724   circle::SpaceToDepthOptionsT *AsSpaceToDepthOptions()
2725   {
2726     return type == BuiltinOptions_SpaceToDepthOptions
2727              ? reinterpret_cast<circle::SpaceToDepthOptionsT *>(value)
2728              : nullptr;
2729   }
2730   const circle::SpaceToDepthOptionsT *AsSpaceToDepthOptions() const
2731   {
2732     return type == BuiltinOptions_SpaceToDepthOptions
2733              ? reinterpret_cast<const circle::SpaceToDepthOptionsT *>(value)
2734              : nullptr;
2735   }
2736   circle::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions()
2737   {
2738     return type == BuiltinOptions_EmbeddingLookupSparseOptions
2739              ? reinterpret_cast<circle::EmbeddingLookupSparseOptionsT *>(value)
2740              : nullptr;
2741   }
2742   const circle::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const
2743   {
2744     return type == BuiltinOptions_EmbeddingLookupSparseOptions
2745              ? reinterpret_cast<const circle::EmbeddingLookupSparseOptionsT *>(value)
2746              : nullptr;
2747   }
2748   circle::MulOptionsT *AsMulOptions()
2749   {
2750     return type == BuiltinOptions_MulOptions ? reinterpret_cast<circle::MulOptionsT *>(value)
2751                                              : nullptr;
2752   }
2753   const circle::MulOptionsT *AsMulOptions() const
2754   {
2755     return type == BuiltinOptions_MulOptions ? reinterpret_cast<const circle::MulOptionsT *>(value)
2756                                              : nullptr;
2757   }
2758   circle::PadOptionsT *AsPadOptions()
2759   {
2760     return type == BuiltinOptions_PadOptions ? reinterpret_cast<circle::PadOptionsT *>(value)
2761                                              : nullptr;
2762   }
2763   const circle::PadOptionsT *AsPadOptions() const
2764   {
2765     return type == BuiltinOptions_PadOptions ? reinterpret_cast<const circle::PadOptionsT *>(value)
2766                                              : nullptr;
2767   }
2768   circle::GatherOptionsT *AsGatherOptions()
2769   {
2770     return type == BuiltinOptions_GatherOptions ? reinterpret_cast<circle::GatherOptionsT *>(value)
2771                                                 : nullptr;
2772   }
2773   const circle::GatherOptionsT *AsGatherOptions() const
2774   {
2775     return type == BuiltinOptions_GatherOptions
2776              ? reinterpret_cast<const circle::GatherOptionsT *>(value)
2777              : nullptr;
2778   }
2779   circle::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions()
2780   {
2781     return type == BuiltinOptions_BatchToSpaceNDOptions
2782              ? reinterpret_cast<circle::BatchToSpaceNDOptionsT *>(value)
2783              : nullptr;
2784   }
2785   const circle::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() const
2786   {
2787     return type == BuiltinOptions_BatchToSpaceNDOptions
2788              ? reinterpret_cast<const circle::BatchToSpaceNDOptionsT *>(value)
2789              : nullptr;
2790   }
2791   circle::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions()
2792   {
2793     return type == BuiltinOptions_SpaceToBatchNDOptions
2794              ? reinterpret_cast<circle::SpaceToBatchNDOptionsT *>(value)
2795              : nullptr;
2796   }
2797   const circle::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() const
2798   {
2799     return type == BuiltinOptions_SpaceToBatchNDOptions
2800              ? reinterpret_cast<const circle::SpaceToBatchNDOptionsT *>(value)
2801              : nullptr;
2802   }
2803   circle::TransposeOptionsT *AsTransposeOptions()
2804   {
2805     return type == BuiltinOptions_TransposeOptions
2806              ? reinterpret_cast<circle::TransposeOptionsT *>(value)
2807              : nullptr;
2808   }
2809   const circle::TransposeOptionsT *AsTransposeOptions() const
2810   {
2811     return type == BuiltinOptions_TransposeOptions
2812              ? reinterpret_cast<const circle::TransposeOptionsT *>(value)
2813              : nullptr;
2814   }
2815   circle::ReducerOptionsT *AsReducerOptions()
2816   {
2817     return type == BuiltinOptions_ReducerOptions
2818              ? reinterpret_cast<circle::ReducerOptionsT *>(value)
2819              : nullptr;
2820   }
2821   const circle::ReducerOptionsT *AsReducerOptions() const
2822   {
2823     return type == BuiltinOptions_ReducerOptions
2824              ? reinterpret_cast<const circle::ReducerOptionsT *>(value)
2825              : nullptr;
2826   }
2827   circle::SubOptionsT *AsSubOptions()
2828   {
2829     return type == BuiltinOptions_SubOptions ? reinterpret_cast<circle::SubOptionsT *>(value)
2830                                              : nullptr;
2831   }
2832   const circle::SubOptionsT *AsSubOptions() const
2833   {
2834     return type == BuiltinOptions_SubOptions ? reinterpret_cast<const circle::SubOptionsT *>(value)
2835                                              : nullptr;
2836   }
2837   circle::DivOptionsT *AsDivOptions()
2838   {
2839     return type == BuiltinOptions_DivOptions ? reinterpret_cast<circle::DivOptionsT *>(value)
2840                                              : nullptr;
2841   }
2842   const circle::DivOptionsT *AsDivOptions() const
2843   {
2844     return type == BuiltinOptions_DivOptions ? reinterpret_cast<const circle::DivOptionsT *>(value)
2845                                              : nullptr;
2846   }
2847   circle::SqueezeOptionsT *AsSqueezeOptions()
2848   {
2849     return type == BuiltinOptions_SqueezeOptions
2850              ? reinterpret_cast<circle::SqueezeOptionsT *>(value)
2851              : nullptr;
2852   }
2853   const circle::SqueezeOptionsT *AsSqueezeOptions() const
2854   {
2855     return type == BuiltinOptions_SqueezeOptions
2856              ? reinterpret_cast<const circle::SqueezeOptionsT *>(value)
2857              : nullptr;
2858   }
2859   circle::SequenceRNNOptionsT *AsSequenceRNNOptions()
2860   {
2861     return type == BuiltinOptions_SequenceRNNOptions
2862              ? reinterpret_cast<circle::SequenceRNNOptionsT *>(value)
2863              : nullptr;
2864   }
2865   const circle::SequenceRNNOptionsT *AsSequenceRNNOptions() const
2866   {
2867     return type == BuiltinOptions_SequenceRNNOptions
2868              ? reinterpret_cast<const circle::SequenceRNNOptionsT *>(value)
2869              : nullptr;
2870   }
2871   circle::StridedSliceOptionsT *AsStridedSliceOptions()
2872   {
2873     return type == BuiltinOptions_StridedSliceOptions
2874              ? reinterpret_cast<circle::StridedSliceOptionsT *>(value)
2875              : nullptr;
2876   }
2877   const circle::StridedSliceOptionsT *AsStridedSliceOptions() const
2878   {
2879     return type == BuiltinOptions_StridedSliceOptions
2880              ? reinterpret_cast<const circle::StridedSliceOptionsT *>(value)
2881              : nullptr;
2882   }
2883   circle::ExpOptionsT *AsExpOptions()
2884   {
2885     return type == BuiltinOptions_ExpOptions ? reinterpret_cast<circle::ExpOptionsT *>(value)
2886                                              : nullptr;
2887   }
2888   const circle::ExpOptionsT *AsExpOptions() const
2889   {
2890     return type == BuiltinOptions_ExpOptions ? reinterpret_cast<const circle::ExpOptionsT *>(value)
2891                                              : nullptr;
2892   }
2893   circle::TopKV2OptionsT *AsTopKV2Options()
2894   {
2895     return type == BuiltinOptions_TopKV2Options ? reinterpret_cast<circle::TopKV2OptionsT *>(value)
2896                                                 : nullptr;
2897   }
2898   const circle::TopKV2OptionsT *AsTopKV2Options() const
2899   {
2900     return type == BuiltinOptions_TopKV2Options
2901              ? reinterpret_cast<const circle::TopKV2OptionsT *>(value)
2902              : nullptr;
2903   }
2904   circle::SplitOptionsT *AsSplitOptions()
2905   {
2906     return type == BuiltinOptions_SplitOptions ? reinterpret_cast<circle::SplitOptionsT *>(value)
2907                                                : nullptr;
2908   }
2909   const circle::SplitOptionsT *AsSplitOptions() const
2910   {
2911     return type == BuiltinOptions_SplitOptions
2912              ? reinterpret_cast<const circle::SplitOptionsT *>(value)
2913              : nullptr;
2914   }
2915   circle::LogSoftmaxOptionsT *AsLogSoftmaxOptions()
2916   {
2917     return type == BuiltinOptions_LogSoftmaxOptions
2918              ? reinterpret_cast<circle::LogSoftmaxOptionsT *>(value)
2919              : nullptr;
2920   }
2921   const circle::LogSoftmaxOptionsT *AsLogSoftmaxOptions() const
2922   {
2923     return type == BuiltinOptions_LogSoftmaxOptions
2924              ? reinterpret_cast<const circle::LogSoftmaxOptionsT *>(value)
2925              : nullptr;
2926   }
2927   circle::CastOptionsT *AsCastOptions()
2928   {
2929     return type == BuiltinOptions_CastOptions ? reinterpret_cast<circle::CastOptionsT *>(value)
2930                                               : nullptr;
2931   }
2932   const circle::CastOptionsT *AsCastOptions() const
2933   {
2934     return type == BuiltinOptions_CastOptions
2935              ? reinterpret_cast<const circle::CastOptionsT *>(value)
2936              : nullptr;
2937   }
2938   circle::DequantizeOptionsT *AsDequantizeOptions()
2939   {
2940     return type == BuiltinOptions_DequantizeOptions
2941              ? reinterpret_cast<circle::DequantizeOptionsT *>(value)
2942              : nullptr;
2943   }
2944   const circle::DequantizeOptionsT *AsDequantizeOptions() const
2945   {
2946     return type == BuiltinOptions_DequantizeOptions
2947              ? reinterpret_cast<const circle::DequantizeOptionsT *>(value)
2948              : nullptr;
2949   }
2950   circle::MaximumMinimumOptionsT *AsMaximumMinimumOptions()
2951   {
2952     return type == BuiltinOptions_MaximumMinimumOptions
2953              ? reinterpret_cast<circle::MaximumMinimumOptionsT *>(value)
2954              : nullptr;
2955   }
2956   const circle::MaximumMinimumOptionsT *AsMaximumMinimumOptions() const
2957   {
2958     return type == BuiltinOptions_MaximumMinimumOptions
2959              ? reinterpret_cast<const circle::MaximumMinimumOptionsT *>(value)
2960              : nullptr;
2961   }
2962   circle::ArgMaxOptionsT *AsArgMaxOptions()
2963   {
2964     return type == BuiltinOptions_ArgMaxOptions ? reinterpret_cast<circle::ArgMaxOptionsT *>(value)
2965                                                 : nullptr;
2966   }
2967   const circle::ArgMaxOptionsT *AsArgMaxOptions() const
2968   {
2969     return type == BuiltinOptions_ArgMaxOptions
2970              ? reinterpret_cast<const circle::ArgMaxOptionsT *>(value)
2971              : nullptr;
2972   }
2973   circle::LessOptionsT *AsLessOptions()
2974   {
2975     return type == BuiltinOptions_LessOptions ? reinterpret_cast<circle::LessOptionsT *>(value)
2976                                               : nullptr;
2977   }
2978   const circle::LessOptionsT *AsLessOptions() const
2979   {
2980     return type == BuiltinOptions_LessOptions
2981              ? reinterpret_cast<const circle::LessOptionsT *>(value)
2982              : nullptr;
2983   }
2984   circle::NegOptionsT *AsNegOptions()
2985   {
2986     return type == BuiltinOptions_NegOptions ? reinterpret_cast<circle::NegOptionsT *>(value)
2987                                              : nullptr;
2988   }
2989   const circle::NegOptionsT *AsNegOptions() const
2990   {
2991     return type == BuiltinOptions_NegOptions ? reinterpret_cast<const circle::NegOptionsT *>(value)
2992                                              : nullptr;
2993   }
2994   circle::PadV2OptionsT *AsPadV2Options()
2995   {
2996     return type == BuiltinOptions_PadV2Options ? reinterpret_cast<circle::PadV2OptionsT *>(value)
2997                                                : nullptr;
2998   }
2999   const circle::PadV2OptionsT *AsPadV2Options() const
3000   {
3001     return type == BuiltinOptions_PadV2Options
3002              ? reinterpret_cast<const circle::PadV2OptionsT *>(value)
3003              : nullptr;
3004   }
3005   circle::GreaterOptionsT *AsGreaterOptions()
3006   {
3007     return type == BuiltinOptions_GreaterOptions
3008              ? reinterpret_cast<circle::GreaterOptionsT *>(value)
3009              : nullptr;
3010   }
3011   const circle::GreaterOptionsT *AsGreaterOptions() const
3012   {
3013     return type == BuiltinOptions_GreaterOptions
3014              ? reinterpret_cast<const circle::GreaterOptionsT *>(value)
3015              : nullptr;
3016   }
3017   circle::GreaterEqualOptionsT *AsGreaterEqualOptions()
3018   {
3019     return type == BuiltinOptions_GreaterEqualOptions
3020              ? reinterpret_cast<circle::GreaterEqualOptionsT *>(value)
3021              : nullptr;
3022   }
3023   const circle::GreaterEqualOptionsT *AsGreaterEqualOptions() const
3024   {
3025     return type == BuiltinOptions_GreaterEqualOptions
3026              ? reinterpret_cast<const circle::GreaterEqualOptionsT *>(value)
3027              : nullptr;
3028   }
3029   circle::LessEqualOptionsT *AsLessEqualOptions()
3030   {
3031     return type == BuiltinOptions_LessEqualOptions
3032              ? reinterpret_cast<circle::LessEqualOptionsT *>(value)
3033              : nullptr;
3034   }
3035   const circle::LessEqualOptionsT *AsLessEqualOptions() const
3036   {
3037     return type == BuiltinOptions_LessEqualOptions
3038              ? reinterpret_cast<const circle::LessEqualOptionsT *>(value)
3039              : nullptr;
3040   }
3041   circle::SelectOptionsT *AsSelectOptions()
3042   {
3043     return type == BuiltinOptions_SelectOptions ? reinterpret_cast<circle::SelectOptionsT *>(value)
3044                                                 : nullptr;
3045   }
3046   const circle::SelectOptionsT *AsSelectOptions() const
3047   {
3048     return type == BuiltinOptions_SelectOptions
3049              ? reinterpret_cast<const circle::SelectOptionsT *>(value)
3050              : nullptr;
3051   }
3052   circle::SliceOptionsT *AsSliceOptions()
3053   {
3054     return type == BuiltinOptions_SliceOptions ? reinterpret_cast<circle::SliceOptionsT *>(value)
3055                                                : nullptr;
3056   }
3057   const circle::SliceOptionsT *AsSliceOptions() const
3058   {
3059     return type == BuiltinOptions_SliceOptions
3060              ? reinterpret_cast<const circle::SliceOptionsT *>(value)
3061              : nullptr;
3062   }
3063   circle::TransposeConvOptionsT *AsTransposeConvOptions()
3064   {
3065     return type == BuiltinOptions_TransposeConvOptions
3066              ? reinterpret_cast<circle::TransposeConvOptionsT *>(value)
3067              : nullptr;
3068   }
3069   const circle::TransposeConvOptionsT *AsTransposeConvOptions() const
3070   {
3071     return type == BuiltinOptions_TransposeConvOptions
3072              ? reinterpret_cast<const circle::TransposeConvOptionsT *>(value)
3073              : nullptr;
3074   }
3075   circle::SparseToDenseOptionsT *AsSparseToDenseOptions()
3076   {
3077     return type == BuiltinOptions_SparseToDenseOptions
3078              ? reinterpret_cast<circle::SparseToDenseOptionsT *>(value)
3079              : nullptr;
3080   }
3081   const circle::SparseToDenseOptionsT *AsSparseToDenseOptions() const
3082   {
3083     return type == BuiltinOptions_SparseToDenseOptions
3084              ? reinterpret_cast<const circle::SparseToDenseOptionsT *>(value)
3085              : nullptr;
3086   }
3087   circle::TileOptionsT *AsTileOptions()
3088   {
3089     return type == BuiltinOptions_TileOptions ? reinterpret_cast<circle::TileOptionsT *>(value)
3090                                               : nullptr;
3091   }
3092   const circle::TileOptionsT *AsTileOptions() const
3093   {
3094     return type == BuiltinOptions_TileOptions
3095              ? reinterpret_cast<const circle::TileOptionsT *>(value)
3096              : nullptr;
3097   }
3098   circle::ExpandDimsOptionsT *AsExpandDimsOptions()
3099   {
3100     return type == BuiltinOptions_ExpandDimsOptions
3101              ? reinterpret_cast<circle::ExpandDimsOptionsT *>(value)
3102              : nullptr;
3103   }
3104   const circle::ExpandDimsOptionsT *AsExpandDimsOptions() const
3105   {
3106     return type == BuiltinOptions_ExpandDimsOptions
3107              ? reinterpret_cast<const circle::ExpandDimsOptionsT *>(value)
3108              : nullptr;
3109   }
3110   circle::EqualOptionsT *AsEqualOptions()
3111   {
3112     return type == BuiltinOptions_EqualOptions ? reinterpret_cast<circle::EqualOptionsT *>(value)
3113                                                : nullptr;
3114   }
3115   const circle::EqualOptionsT *AsEqualOptions() const
3116   {
3117     return type == BuiltinOptions_EqualOptions
3118              ? reinterpret_cast<const circle::EqualOptionsT *>(value)
3119              : nullptr;
3120   }
3121   circle::NotEqualOptionsT *AsNotEqualOptions()
3122   {
3123     return type == BuiltinOptions_NotEqualOptions
3124              ? reinterpret_cast<circle::NotEqualOptionsT *>(value)
3125              : nullptr;
3126   }
3127   const circle::NotEqualOptionsT *AsNotEqualOptions() const
3128   {
3129     return type == BuiltinOptions_NotEqualOptions
3130              ? reinterpret_cast<const circle::NotEqualOptionsT *>(value)
3131              : nullptr;
3132   }
3133   circle::ShapeOptionsT *AsShapeOptions()
3134   {
3135     return type == BuiltinOptions_ShapeOptions ? reinterpret_cast<circle::ShapeOptionsT *>(value)
3136                                                : nullptr;
3137   }
3138   const circle::ShapeOptionsT *AsShapeOptions() const
3139   {
3140     return type == BuiltinOptions_ShapeOptions
3141              ? reinterpret_cast<const circle::ShapeOptionsT *>(value)
3142              : nullptr;
3143   }
3144   circle::PowOptionsT *AsPowOptions()
3145   {
3146     return type == BuiltinOptions_PowOptions ? reinterpret_cast<circle::PowOptionsT *>(value)
3147                                              : nullptr;
3148   }
3149   const circle::PowOptionsT *AsPowOptions() const
3150   {
3151     return type == BuiltinOptions_PowOptions ? reinterpret_cast<const circle::PowOptionsT *>(value)
3152                                              : nullptr;
3153   }
3154   circle::ArgMinOptionsT *AsArgMinOptions()
3155   {
3156     return type == BuiltinOptions_ArgMinOptions ? reinterpret_cast<circle::ArgMinOptionsT *>(value)
3157                                                 : nullptr;
3158   }
3159   const circle::ArgMinOptionsT *AsArgMinOptions() const
3160   {
3161     return type == BuiltinOptions_ArgMinOptions
3162              ? reinterpret_cast<const circle::ArgMinOptionsT *>(value)
3163              : nullptr;
3164   }
3165   circle::FakeQuantOptionsT *AsFakeQuantOptions()
3166   {
3167     return type == BuiltinOptions_FakeQuantOptions
3168              ? reinterpret_cast<circle::FakeQuantOptionsT *>(value)
3169              : nullptr;
3170   }
3171   const circle::FakeQuantOptionsT *AsFakeQuantOptions() const
3172   {
3173     return type == BuiltinOptions_FakeQuantOptions
3174              ? reinterpret_cast<const circle::FakeQuantOptionsT *>(value)
3175              : nullptr;
3176   }
3177   circle::PackOptionsT *AsPackOptions()
3178   {
3179     return type == BuiltinOptions_PackOptions ? reinterpret_cast<circle::PackOptionsT *>(value)
3180                                               : nullptr;
3181   }
3182   const circle::PackOptionsT *AsPackOptions() const
3183   {
3184     return type == BuiltinOptions_PackOptions
3185              ? reinterpret_cast<const circle::PackOptionsT *>(value)
3186              : nullptr;
3187   }
3188   circle::LogicalOrOptionsT *AsLogicalOrOptions()
3189   {
3190     return type == BuiltinOptions_LogicalOrOptions
3191              ? reinterpret_cast<circle::LogicalOrOptionsT *>(value)
3192              : nullptr;
3193   }
3194   const circle::LogicalOrOptionsT *AsLogicalOrOptions() const
3195   {
3196     return type == BuiltinOptions_LogicalOrOptions
3197              ? reinterpret_cast<const circle::LogicalOrOptionsT *>(value)
3198              : nullptr;
3199   }
3200   circle::OneHotOptionsT *AsOneHotOptions()
3201   {
3202     return type == BuiltinOptions_OneHotOptions ? reinterpret_cast<circle::OneHotOptionsT *>(value)
3203                                                 : nullptr;
3204   }
3205   const circle::OneHotOptionsT *AsOneHotOptions() const
3206   {
3207     return type == BuiltinOptions_OneHotOptions
3208              ? reinterpret_cast<const circle::OneHotOptionsT *>(value)
3209              : nullptr;
3210   }
3211   circle::LogicalAndOptionsT *AsLogicalAndOptions()
3212   {
3213     return type == BuiltinOptions_LogicalAndOptions
3214              ? reinterpret_cast<circle::LogicalAndOptionsT *>(value)
3215              : nullptr;
3216   }
3217   const circle::LogicalAndOptionsT *AsLogicalAndOptions() const
3218   {
3219     return type == BuiltinOptions_LogicalAndOptions
3220              ? reinterpret_cast<const circle::LogicalAndOptionsT *>(value)
3221              : nullptr;
3222   }
3223   circle::LogicalNotOptionsT *AsLogicalNotOptions()
3224   {
3225     return type == BuiltinOptions_LogicalNotOptions
3226              ? reinterpret_cast<circle::LogicalNotOptionsT *>(value)
3227              : nullptr;
3228   }
3229   const circle::LogicalNotOptionsT *AsLogicalNotOptions() const
3230   {
3231     return type == BuiltinOptions_LogicalNotOptions
3232              ? reinterpret_cast<const circle::LogicalNotOptionsT *>(value)
3233              : nullptr;
3234   }
3235   circle::UnpackOptionsT *AsUnpackOptions()
3236   {
3237     return type == BuiltinOptions_UnpackOptions ? reinterpret_cast<circle::UnpackOptionsT *>(value)
3238                                                 : nullptr;
3239   }
3240   const circle::UnpackOptionsT *AsUnpackOptions() const
3241   {
3242     return type == BuiltinOptions_UnpackOptions
3243              ? reinterpret_cast<const circle::UnpackOptionsT *>(value)
3244              : nullptr;
3245   }
3246   circle::FloorDivOptionsT *AsFloorDivOptions()
3247   {
3248     return type == BuiltinOptions_FloorDivOptions
3249              ? reinterpret_cast<circle::FloorDivOptionsT *>(value)
3250              : nullptr;
3251   }
3252   const circle::FloorDivOptionsT *AsFloorDivOptions() const
3253   {
3254     return type == BuiltinOptions_FloorDivOptions
3255              ? reinterpret_cast<const circle::FloorDivOptionsT *>(value)
3256              : nullptr;
3257   }
3258   circle::SquareOptionsT *AsSquareOptions()
3259   {
3260     return type == BuiltinOptions_SquareOptions ? reinterpret_cast<circle::SquareOptionsT *>(value)
3261                                                 : nullptr;
3262   }
3263   const circle::SquareOptionsT *AsSquareOptions() const
3264   {
3265     return type == BuiltinOptions_SquareOptions
3266              ? reinterpret_cast<const circle::SquareOptionsT *>(value)
3267              : nullptr;
3268   }
3269   circle::ZerosLikeOptionsT *AsZerosLikeOptions()
3270   {
3271     return type == BuiltinOptions_ZerosLikeOptions
3272              ? reinterpret_cast<circle::ZerosLikeOptionsT *>(value)
3273              : nullptr;
3274   }
3275   const circle::ZerosLikeOptionsT *AsZerosLikeOptions() const
3276   {
3277     return type == BuiltinOptions_ZerosLikeOptions
3278              ? reinterpret_cast<const circle::ZerosLikeOptionsT *>(value)
3279              : nullptr;
3280   }
3281   circle::FillOptionsT *AsFillOptions()
3282   {
3283     return type == BuiltinOptions_FillOptions ? reinterpret_cast<circle::FillOptionsT *>(value)
3284                                               : nullptr;
3285   }
3286   const circle::FillOptionsT *AsFillOptions() const
3287   {
3288     return type == BuiltinOptions_FillOptions
3289              ? reinterpret_cast<const circle::FillOptionsT *>(value)
3290              : nullptr;
3291   }
3292   circle::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions()
3293   {
3294     return type == BuiltinOptions_BidirectionalSequenceLSTMOptions
3295              ? reinterpret_cast<circle::BidirectionalSequenceLSTMOptionsT *>(value)
3296              : nullptr;
3297   }
3298   const circle::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() const
3299   {
3300     return type == BuiltinOptions_BidirectionalSequenceLSTMOptions
3301              ? reinterpret_cast<const circle::BidirectionalSequenceLSTMOptionsT *>(value)
3302              : nullptr;
3303   }
3304   circle::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions()
3305   {
3306     return type == BuiltinOptions_BidirectionalSequenceRNNOptions
3307              ? reinterpret_cast<circle::BidirectionalSequenceRNNOptionsT *>(value)
3308              : nullptr;
3309   }
3310   const circle::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() const
3311   {
3312     return type == BuiltinOptions_BidirectionalSequenceRNNOptions
3313              ? reinterpret_cast<const circle::BidirectionalSequenceRNNOptionsT *>(value)
3314              : nullptr;
3315   }
3316   circle::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions()
3317   {
3318     return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions
3319              ? reinterpret_cast<circle::UnidirectionalSequenceLSTMOptionsT *>(value)
3320              : nullptr;
3321   }
3322   const circle::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() const
3323   {
3324     return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions
3325              ? reinterpret_cast<const circle::UnidirectionalSequenceLSTMOptionsT *>(value)
3326              : nullptr;
3327   }
3328   circle::FloorModOptionsT *AsFloorModOptions()
3329   {
3330     return type == BuiltinOptions_FloorModOptions
3331              ? reinterpret_cast<circle::FloorModOptionsT *>(value)
3332              : nullptr;
3333   }
3334   const circle::FloorModOptionsT *AsFloorModOptions() const
3335   {
3336     return type == BuiltinOptions_FloorModOptions
3337              ? reinterpret_cast<const circle::FloorModOptionsT *>(value)
3338              : nullptr;
3339   }
3340   circle::RangeOptionsT *AsRangeOptions()
3341   {
3342     return type == BuiltinOptions_RangeOptions ? reinterpret_cast<circle::RangeOptionsT *>(value)
3343                                                : nullptr;
3344   }
3345   const circle::RangeOptionsT *AsRangeOptions() const
3346   {
3347     return type == BuiltinOptions_RangeOptions
3348              ? reinterpret_cast<const circle::RangeOptionsT *>(value)
3349              : nullptr;
3350   }
3351   circle::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions()
3352   {
3353     return type == BuiltinOptions_ResizeNearestNeighborOptions
3354              ? reinterpret_cast<circle::ResizeNearestNeighborOptionsT *>(value)
3355              : nullptr;
3356   }
3357   const circle::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() const
3358   {
3359     return type == BuiltinOptions_ResizeNearestNeighborOptions
3360              ? reinterpret_cast<const circle::ResizeNearestNeighborOptionsT *>(value)
3361              : nullptr;
3362   }
3363   circle::LeakyReluOptionsT *AsLeakyReluOptions()
3364   {
3365     return type == BuiltinOptions_LeakyReluOptions
3366              ? reinterpret_cast<circle::LeakyReluOptionsT *>(value)
3367              : nullptr;
3368   }
3369   const circle::LeakyReluOptionsT *AsLeakyReluOptions() const
3370   {
3371     return type == BuiltinOptions_LeakyReluOptions
3372              ? reinterpret_cast<const circle::LeakyReluOptionsT *>(value)
3373              : nullptr;
3374   }
3375   circle::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions()
3376   {
3377     return type == BuiltinOptions_SquaredDifferenceOptions
3378              ? reinterpret_cast<circle::SquaredDifferenceOptionsT *>(value)
3379              : nullptr;
3380   }
3381   const circle::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() const
3382   {
3383     return type == BuiltinOptions_SquaredDifferenceOptions
3384              ? reinterpret_cast<const circle::SquaredDifferenceOptionsT *>(value)
3385              : nullptr;
3386   }
3387   circle::MirrorPadOptionsT *AsMirrorPadOptions()
3388   {
3389     return type == BuiltinOptions_MirrorPadOptions
3390              ? reinterpret_cast<circle::MirrorPadOptionsT *>(value)
3391              : nullptr;
3392   }
3393   const circle::MirrorPadOptionsT *AsMirrorPadOptions() const
3394   {
3395     return type == BuiltinOptions_MirrorPadOptions
3396              ? reinterpret_cast<const circle::MirrorPadOptionsT *>(value)
3397              : nullptr;
3398   }
3399   circle::AbsOptionsT *AsAbsOptions()
3400   {
3401     return type == BuiltinOptions_AbsOptions ? reinterpret_cast<circle::AbsOptionsT *>(value)
3402                                              : nullptr;
3403   }
3404   const circle::AbsOptionsT *AsAbsOptions() const
3405   {
3406     return type == BuiltinOptions_AbsOptions ? reinterpret_cast<const circle::AbsOptionsT *>(value)
3407                                              : nullptr;
3408   }
3409   circle::SplitVOptionsT *AsSplitVOptions()
3410   {
3411     return type == BuiltinOptions_SplitVOptions ? reinterpret_cast<circle::SplitVOptionsT *>(value)
3412                                                 : nullptr;
3413   }
3414   const circle::SplitVOptionsT *AsSplitVOptions() const
3415   {
3416     return type == BuiltinOptions_SplitVOptions
3417              ? reinterpret_cast<const circle::SplitVOptionsT *>(value)
3418              : nullptr;
3419   }
3420   circle::UniqueOptionsT *AsUniqueOptions()
3421   {
3422     return type == BuiltinOptions_UniqueOptions ? reinterpret_cast<circle::UniqueOptionsT *>(value)
3423                                                 : nullptr;
3424   }
3425   const circle::UniqueOptionsT *AsUniqueOptions() const
3426   {
3427     return type == BuiltinOptions_UniqueOptions
3428              ? reinterpret_cast<const circle::UniqueOptionsT *>(value)
3429              : nullptr;
3430   }
3431   circle::ReverseV2OptionsT *AsReverseV2Options()
3432   {
3433     return type == BuiltinOptions_ReverseV2Options
3434              ? reinterpret_cast<circle::ReverseV2OptionsT *>(value)
3435              : nullptr;
3436   }
3437   const circle::ReverseV2OptionsT *AsReverseV2Options() const
3438   {
3439     return type == BuiltinOptions_ReverseV2Options
3440              ? reinterpret_cast<const circle::ReverseV2OptionsT *>(value)
3441              : nullptr;
3442   }
3443   circle::AddNOptionsT *AsAddNOptions()
3444   {
3445     return type == BuiltinOptions_AddNOptions ? reinterpret_cast<circle::AddNOptionsT *>(value)
3446                                               : nullptr;
3447   }
3448   const circle::AddNOptionsT *AsAddNOptions() const
3449   {
3450     return type == BuiltinOptions_AddNOptions
3451              ? reinterpret_cast<const circle::AddNOptionsT *>(value)
3452              : nullptr;
3453   }
3454   circle::GatherNdOptionsT *AsGatherNdOptions()
3455   {
3456     return type == BuiltinOptions_GatherNdOptions
3457              ? reinterpret_cast<circle::GatherNdOptionsT *>(value)
3458              : nullptr;
3459   }
3460   const circle::GatherNdOptionsT *AsGatherNdOptions() const
3461   {
3462     return type == BuiltinOptions_GatherNdOptions
3463              ? reinterpret_cast<const circle::GatherNdOptionsT *>(value)
3464              : nullptr;
3465   }
3466   circle::CosOptionsT *AsCosOptions()
3467   {
3468     return type == BuiltinOptions_CosOptions ? reinterpret_cast<circle::CosOptionsT *>(value)
3469                                              : nullptr;
3470   }
3471   const circle::CosOptionsT *AsCosOptions() const
3472   {
3473     return type == BuiltinOptions_CosOptions ? reinterpret_cast<const circle::CosOptionsT *>(value)
3474                                              : nullptr;
3475   }
3476   circle::WhereOptionsT *AsWhereOptions()
3477   {
3478     return type == BuiltinOptions_WhereOptions ? reinterpret_cast<circle::WhereOptionsT *>(value)
3479                                                : nullptr;
3480   }
3481   const circle::WhereOptionsT *AsWhereOptions() const
3482   {
3483     return type == BuiltinOptions_WhereOptions
3484              ? reinterpret_cast<const circle::WhereOptionsT *>(value)
3485              : nullptr;
3486   }
3487   circle::RankOptionsT *AsRankOptions()
3488   {
3489     return type == BuiltinOptions_RankOptions ? reinterpret_cast<circle::RankOptionsT *>(value)
3490                                               : nullptr;
3491   }
3492   const circle::RankOptionsT *AsRankOptions() const
3493   {
3494     return type == BuiltinOptions_RankOptions
3495              ? reinterpret_cast<const circle::RankOptionsT *>(value)
3496              : nullptr;
3497   }
3498   circle::ReverseSequenceOptionsT *AsReverseSequenceOptions()
3499   {
3500     return type == BuiltinOptions_ReverseSequenceOptions
3501              ? reinterpret_cast<circle::ReverseSequenceOptionsT *>(value)
3502              : nullptr;
3503   }
3504   const circle::ReverseSequenceOptionsT *AsReverseSequenceOptions() const
3505   {
3506     return type == BuiltinOptions_ReverseSequenceOptions
3507              ? reinterpret_cast<const circle::ReverseSequenceOptionsT *>(value)
3508              : nullptr;
3509   }
3510   circle::MatrixDiagOptionsT *AsMatrixDiagOptions()
3511   {
3512     return type == BuiltinOptions_MatrixDiagOptions
3513              ? reinterpret_cast<circle::MatrixDiagOptionsT *>(value)
3514              : nullptr;
3515   }
3516   const circle::MatrixDiagOptionsT *AsMatrixDiagOptions() const
3517   {
3518     return type == BuiltinOptions_MatrixDiagOptions
3519              ? reinterpret_cast<const circle::MatrixDiagOptionsT *>(value)
3520              : nullptr;
3521   }
3522   circle::QuantizeOptionsT *AsQuantizeOptions()
3523   {
3524     return type == BuiltinOptions_QuantizeOptions
3525              ? reinterpret_cast<circle::QuantizeOptionsT *>(value)
3526              : nullptr;
3527   }
3528   const circle::QuantizeOptionsT *AsQuantizeOptions() const
3529   {
3530     return type == BuiltinOptions_QuantizeOptions
3531              ? reinterpret_cast<const circle::QuantizeOptionsT *>(value)
3532              : nullptr;
3533   }
3534   circle::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions()
3535   {
3536     return type == BuiltinOptions_MatrixSetDiagOptions
3537              ? reinterpret_cast<circle::MatrixSetDiagOptionsT *>(value)
3538              : nullptr;
3539   }
3540   const circle::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() const
3541   {
3542     return type == BuiltinOptions_MatrixSetDiagOptions
3543              ? reinterpret_cast<const circle::MatrixSetDiagOptionsT *>(value)
3544              : nullptr;
3545   }
3546   circle::HardSwishOptionsT *AsHardSwishOptions()
3547   {
3548     return type == BuiltinOptions_HardSwishOptions
3549              ? reinterpret_cast<circle::HardSwishOptionsT *>(value)
3550              : nullptr;
3551   }
3552   const circle::HardSwishOptionsT *AsHardSwishOptions() const
3553   {
3554     return type == BuiltinOptions_HardSwishOptions
3555              ? reinterpret_cast<const circle::HardSwishOptionsT *>(value)
3556              : nullptr;
3557   }
3558   circle::IfOptionsT *AsIfOptions()
3559   {
3560     return type == BuiltinOptions_IfOptions ? reinterpret_cast<circle::IfOptionsT *>(value)
3561                                             : nullptr;
3562   }
3563   const circle::IfOptionsT *AsIfOptions() const
3564   {
3565     return type == BuiltinOptions_IfOptions ? reinterpret_cast<const circle::IfOptionsT *>(value)
3566                                             : nullptr;
3567   }
3568   circle::WhileOptionsT *AsWhileOptions()
3569   {
3570     return type == BuiltinOptions_WhileOptions ? reinterpret_cast<circle::WhileOptionsT *>(value)
3571                                                : nullptr;
3572   }
3573   const circle::WhileOptionsT *AsWhileOptions() const
3574   {
3575     return type == BuiltinOptions_WhileOptions
3576              ? reinterpret_cast<const circle::WhileOptionsT *>(value)
3577              : nullptr;
3578   }
3579   circle::DepthToSpaceOptionsT *AsDepthToSpaceOptions()
3580   {
3581     return type == BuiltinOptions_DepthToSpaceOptions
3582              ? reinterpret_cast<circle::DepthToSpaceOptionsT *>(value)
3583              : nullptr;
3584   }
3585   const circle::DepthToSpaceOptionsT *AsDepthToSpaceOptions() const
3586   {
3587     return type == BuiltinOptions_DepthToSpaceOptions
3588              ? reinterpret_cast<const circle::DepthToSpaceOptionsT *>(value)
3589              : nullptr;
3590   }
3591   circle::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options()
3592   {
3593     return type == BuiltinOptions_NonMaxSuppressionV4Options
3594              ? reinterpret_cast<circle::NonMaxSuppressionV4OptionsT *>(value)
3595              : nullptr;
3596   }
3597   const circle::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() const
3598   {
3599     return type == BuiltinOptions_NonMaxSuppressionV4Options
3600              ? reinterpret_cast<const circle::NonMaxSuppressionV4OptionsT *>(value)
3601              : nullptr;
3602   }
3603   circle::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options()
3604   {
3605     return type == BuiltinOptions_NonMaxSuppressionV5Options
3606              ? reinterpret_cast<circle::NonMaxSuppressionV5OptionsT *>(value)
3607              : nullptr;
3608   }
3609   const circle::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() const
3610   {
3611     return type == BuiltinOptions_NonMaxSuppressionV5Options
3612              ? reinterpret_cast<const circle::NonMaxSuppressionV5OptionsT *>(value)
3613              : nullptr;
3614   }
3615   circle::ScatterNdOptionsT *AsScatterNdOptions()
3616   {
3617     return type == BuiltinOptions_ScatterNdOptions
3618              ? reinterpret_cast<circle::ScatterNdOptionsT *>(value)
3619              : nullptr;
3620   }
3621   const circle::ScatterNdOptionsT *AsScatterNdOptions() const
3622   {
3623     return type == BuiltinOptions_ScatterNdOptions
3624              ? reinterpret_cast<const circle::ScatterNdOptionsT *>(value)
3625              : nullptr;
3626   }
3627   circle::SelectV2OptionsT *AsSelectV2Options()
3628   {
3629     return type == BuiltinOptions_SelectV2Options
3630              ? reinterpret_cast<circle::SelectV2OptionsT *>(value)
3631              : nullptr;
3632   }
3633   const circle::SelectV2OptionsT *AsSelectV2Options() const
3634   {
3635     return type == BuiltinOptions_SelectV2Options
3636              ? reinterpret_cast<const circle::SelectV2OptionsT *>(value)
3637              : nullptr;
3638   }
3639   circle::DensifyOptionsT *AsDensifyOptions()
3640   {
3641     return type == BuiltinOptions_DensifyOptions
3642              ? reinterpret_cast<circle::DensifyOptionsT *>(value)
3643              : nullptr;
3644   }
3645   const circle::DensifyOptionsT *AsDensifyOptions() const
3646   {
3647     return type == BuiltinOptions_DensifyOptions
3648              ? reinterpret_cast<const circle::DensifyOptionsT *>(value)
3649              : nullptr;
3650   }
3651   circle::SegmentSumOptionsT *AsSegmentSumOptions()
3652   {
3653     return type == BuiltinOptions_SegmentSumOptions
3654              ? reinterpret_cast<circle::SegmentSumOptionsT *>(value)
3655              : nullptr;
3656   }
3657   const circle::SegmentSumOptionsT *AsSegmentSumOptions() const
3658   {
3659     return type == BuiltinOptions_SegmentSumOptions
3660              ? reinterpret_cast<const circle::SegmentSumOptionsT *>(value)
3661              : nullptr;
3662   }
3663   circle::BatchMatMulOptionsT *AsBatchMatMulOptions()
3664   {
3665     return type == BuiltinOptions_BatchMatMulOptions
3666              ? reinterpret_cast<circle::BatchMatMulOptionsT *>(value)
3667              : nullptr;
3668   }
3669   const circle::BatchMatMulOptionsT *AsBatchMatMulOptions() const
3670   {
3671     return type == BuiltinOptions_BatchMatMulOptions
3672              ? reinterpret_cast<const circle::BatchMatMulOptionsT *>(value)
3673              : nullptr;
3674   }
3675   circle::CumsumOptionsT *AsCumsumOptions()
3676   {
3677     return type == BuiltinOptions_CumsumOptions ? reinterpret_cast<circle::CumsumOptionsT *>(value)
3678                                                 : nullptr;
3679   }
3680   const circle::CumsumOptionsT *AsCumsumOptions() const
3681   {
3682     return type == BuiltinOptions_CumsumOptions
3683              ? reinterpret_cast<const circle::CumsumOptionsT *>(value)
3684              : nullptr;
3685   }
3686   circle::CallOnceOptionsT *AsCallOnceOptions()
3687   {
3688     return type == BuiltinOptions_CallOnceOptions
3689              ? reinterpret_cast<circle::CallOnceOptionsT *>(value)
3690              : nullptr;
3691   }
3692   const circle::CallOnceOptionsT *AsCallOnceOptions() const
3693   {
3694     return type == BuiltinOptions_CallOnceOptions
3695              ? reinterpret_cast<const circle::CallOnceOptionsT *>(value)
3696              : nullptr;
3697   }
3698   circle::BroadcastToOptionsT *AsBroadcastToOptions()
3699   {
3700     return type == BuiltinOptions_BroadcastToOptions
3701              ? reinterpret_cast<circle::BroadcastToOptionsT *>(value)
3702              : nullptr;
3703   }
3704   const circle::BroadcastToOptionsT *AsBroadcastToOptions() const
3705   {
3706     return type == BuiltinOptions_BroadcastToOptions
3707              ? reinterpret_cast<const circle::BroadcastToOptionsT *>(value)
3708              : nullptr;
3709   }
3710   circle::Rfft2dOptionsT *AsRfft2dOptions()
3711   {
3712     return type == BuiltinOptions_Rfft2dOptions ? reinterpret_cast<circle::Rfft2dOptionsT *>(value)
3713                                                 : nullptr;
3714   }
3715   const circle::Rfft2dOptionsT *AsRfft2dOptions() const
3716   {
3717     return type == BuiltinOptions_Rfft2dOptions
3718              ? reinterpret_cast<const circle::Rfft2dOptionsT *>(value)
3719              : nullptr;
3720   }
3721   circle::Conv3DOptionsT *AsConv3DOptions()
3722   {
3723     return type == BuiltinOptions_Conv3DOptions ? reinterpret_cast<circle::Conv3DOptionsT *>(value)
3724                                                 : nullptr;
3725   }
3726   const circle::Conv3DOptionsT *AsConv3DOptions() const
3727   {
3728     return type == BuiltinOptions_Conv3DOptions
3729              ? reinterpret_cast<const circle::Conv3DOptionsT *>(value)
3730              : nullptr;
3731   }
3732   circle::HashtableOptionsT *AsHashtableOptions()
3733   {
3734     return type == BuiltinOptions_HashtableOptions
3735              ? reinterpret_cast<circle::HashtableOptionsT *>(value)
3736              : nullptr;
3737   }
3738   const circle::HashtableOptionsT *AsHashtableOptions() const
3739   {
3740     return type == BuiltinOptions_HashtableOptions
3741              ? reinterpret_cast<const circle::HashtableOptionsT *>(value)
3742              : nullptr;
3743   }
3744   circle::HashtableFindOptionsT *AsHashtableFindOptions()
3745   {
3746     return type == BuiltinOptions_HashtableFindOptions
3747              ? reinterpret_cast<circle::HashtableFindOptionsT *>(value)
3748              : nullptr;
3749   }
3750   const circle::HashtableFindOptionsT *AsHashtableFindOptions() const
3751   {
3752     return type == BuiltinOptions_HashtableFindOptions
3753              ? reinterpret_cast<const circle::HashtableFindOptionsT *>(value)
3754              : nullptr;
3755   }
3756   circle::HashtableImportOptionsT *AsHashtableImportOptions()
3757   {
3758     return type == BuiltinOptions_HashtableImportOptions
3759              ? reinterpret_cast<circle::HashtableImportOptionsT *>(value)
3760              : nullptr;
3761   }
3762   const circle::HashtableImportOptionsT *AsHashtableImportOptions() const
3763   {
3764     return type == BuiltinOptions_HashtableImportOptions
3765              ? reinterpret_cast<const circle::HashtableImportOptionsT *>(value)
3766              : nullptr;
3767   }
3768   circle::HashtableSizeOptionsT *AsHashtableSizeOptions()
3769   {
3770     return type == BuiltinOptions_HashtableSizeOptions
3771              ? reinterpret_cast<circle::HashtableSizeOptionsT *>(value)
3772              : nullptr;
3773   }
3774   const circle::HashtableSizeOptionsT *AsHashtableSizeOptions() const
3775   {
3776     return type == BuiltinOptions_HashtableSizeOptions
3777              ? reinterpret_cast<const circle::HashtableSizeOptionsT *>(value)
3778              : nullptr;
3779   }
3780   circle::VarHandleOptionsT *AsVarHandleOptions()
3781   {
3782     return type == BuiltinOptions_VarHandleOptions
3783              ? reinterpret_cast<circle::VarHandleOptionsT *>(value)
3784              : nullptr;
3785   }
3786   const circle::VarHandleOptionsT *AsVarHandleOptions() const
3787   {
3788     return type == BuiltinOptions_VarHandleOptions
3789              ? reinterpret_cast<const circle::VarHandleOptionsT *>(value)
3790              : nullptr;
3791   }
3792   circle::ReadVariableOptionsT *AsReadVariableOptions()
3793   {
3794     return type == BuiltinOptions_ReadVariableOptions
3795              ? reinterpret_cast<circle::ReadVariableOptionsT *>(value)
3796              : nullptr;
3797   }
3798   const circle::ReadVariableOptionsT *AsReadVariableOptions() const
3799   {
3800     return type == BuiltinOptions_ReadVariableOptions
3801              ? reinterpret_cast<const circle::ReadVariableOptionsT *>(value)
3802              : nullptr;
3803   }
3804   circle::AssignVariableOptionsT *AsAssignVariableOptions()
3805   {
3806     return type == BuiltinOptions_AssignVariableOptions
3807              ? reinterpret_cast<circle::AssignVariableOptionsT *>(value)
3808              : nullptr;
3809   }
3810   const circle::AssignVariableOptionsT *AsAssignVariableOptions() const
3811   {
3812     return type == BuiltinOptions_AssignVariableOptions
3813              ? reinterpret_cast<const circle::AssignVariableOptionsT *>(value)
3814              : nullptr;
3815   }
3816   circle::RandomOptionsT *AsRandomOptions()
3817   {
3818     return type == BuiltinOptions_RandomOptions ? reinterpret_cast<circle::RandomOptionsT *>(value)
3819                                                 : nullptr;
3820   }
3821   const circle::RandomOptionsT *AsRandomOptions() const
3822   {
3823     return type == BuiltinOptions_RandomOptions
3824              ? reinterpret_cast<const circle::RandomOptionsT *>(value)
3825              : nullptr;
3826   }
3827   circle::BCQGatherOptionsT *AsBCQGatherOptions()
3828   {
3829     return type == BuiltinOptions_BCQGatherOptions
3830              ? reinterpret_cast<circle::BCQGatherOptionsT *>(value)
3831              : nullptr;
3832   }
3833   const circle::BCQGatherOptionsT *AsBCQGatherOptions() const
3834   {
3835     return type == BuiltinOptions_BCQGatherOptions
3836              ? reinterpret_cast<const circle::BCQGatherOptionsT *>(value)
3837              : nullptr;
3838   }
3839   circle::BCQFullyConnectedOptionsT *AsBCQFullyConnectedOptions()
3840   {
3841     return type == BuiltinOptions_BCQFullyConnectedOptions
3842              ? reinterpret_cast<circle::BCQFullyConnectedOptionsT *>(value)
3843              : nullptr;
3844   }
3845   const circle::BCQFullyConnectedOptionsT *AsBCQFullyConnectedOptions() const
3846   {
3847     return type == BuiltinOptions_BCQFullyConnectedOptions
3848              ? reinterpret_cast<const circle::BCQFullyConnectedOptionsT *>(value)
3849              : nullptr;
3850   }
3851   circle::InstanceNormOptionsT *AsInstanceNormOptions()
3852   {
3853     return type == BuiltinOptions_InstanceNormOptions
3854              ? reinterpret_cast<circle::InstanceNormOptionsT *>(value)
3855              : nullptr;
3856   }
3857   const circle::InstanceNormOptionsT *AsInstanceNormOptions() const
3858   {
3859     return type == BuiltinOptions_InstanceNormOptions
3860              ? reinterpret_cast<const circle::InstanceNormOptionsT *>(value)
3861              : nullptr;
3862   }
3863 };
3864
3865 bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
3866 bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
3867                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
3868                                 const flatbuffers::Vector<uint8_t> *types);
3869
3870 enum Padding : int8_t
3871 {
3872   Padding_SAME = 0,
3873   Padding_VALID = 1,
3874   Padding_MIN = Padding_SAME,
3875   Padding_MAX = Padding_VALID
3876 };
3877
3878 inline const Padding (&EnumValuesPadding())[2]
3879 {
3880   static const Padding values[] = {Padding_SAME, Padding_VALID};
3881   return values;
3882 }
3883
3884 inline const char *const *EnumNamesPadding()
3885 {
3886   static const char *const names[3] = {"SAME", "VALID", nullptr};
3887   return names;
3888 }
3889
3890 inline const char *EnumNamePadding(Padding e)
3891 {
3892   if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID))
3893     return "";
3894   const size_t index = static_cast<size_t>(e);
3895   return EnumNamesPadding()[index];
3896 }
3897
3898 enum ActivationFunctionType : int8_t
3899 {
3900   ActivationFunctionType_NONE = 0,
3901   ActivationFunctionType_RELU = 1,
3902   ActivationFunctionType_RELU_N1_TO_1 = 2,
3903   ActivationFunctionType_RELU6 = 3,
3904   ActivationFunctionType_TANH = 4,
3905   ActivationFunctionType_SIGN_BIT = 5,
3906   ActivationFunctionType_MIN = ActivationFunctionType_NONE,
3907   ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
3908 };
3909
3910 inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6]
3911 {
3912   static const ActivationFunctionType values[] = {
3913     ActivationFunctionType_NONE,  ActivationFunctionType_RELU, ActivationFunctionType_RELU_N1_TO_1,
3914     ActivationFunctionType_RELU6, ActivationFunctionType_TANH, ActivationFunctionType_SIGN_BIT};
3915   return values;
3916 }
3917
3918 inline const char *const *EnumNamesActivationFunctionType()
3919 {
3920   static const char *const names[7] = {"NONE", "RELU",     "RELU_N1_TO_1", "RELU6",
3921                                        "TANH", "SIGN_BIT", nullptr};
3922   return names;
3923 }
3924
3925 inline const char *EnumNameActivationFunctionType(ActivationFunctionType e)
3926 {
3927   if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT))
3928     return "";
3929   const size_t index = static_cast<size_t>(e);
3930   return EnumNamesActivationFunctionType()[index];
3931 }
3932
3933 enum LSHProjectionType : int8_t
3934 {
3935   LSHProjectionType_UNKNOWN = 0,
3936   LSHProjectionType_SPARSE = 1,
3937   LSHProjectionType_DENSE = 2,
3938   LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
3939   LSHProjectionType_MAX = LSHProjectionType_DENSE
3940 };
3941
3942 inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3]
3943 {
3944   static const LSHProjectionType values[] = {LSHProjectionType_UNKNOWN, LSHProjectionType_SPARSE,
3945                                              LSHProjectionType_DENSE};
3946   return values;
3947 }
3948
3949 inline const char *const *EnumNamesLSHProjectionType()
3950 {
3951   static const char *const names[4] = {"UNKNOWN", "SPARSE", "DENSE", nullptr};
3952   return names;
3953 }
3954
3955 inline const char *EnumNameLSHProjectionType(LSHProjectionType e)
3956 {
3957   if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE))
3958     return "";
3959   const size_t index = static_cast<size_t>(e);
3960   return EnumNamesLSHProjectionType()[index];
3961 }
3962
3963 enum FullyConnectedOptionsWeightsFormat : int8_t
3964 {
3965   FullyConnectedOptionsWeightsFormat_DEFAULT = 0,
3966   FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1,
3967   FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32 = 127,
3968   FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
3969   FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32
3970 };
3971
3972 inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[3]
3973 {
3974   static const FullyConnectedOptionsWeightsFormat values[] = {
3975     FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8,
3976     FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32};
3977   return values;
3978 }
3979
3980 inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e)
3981 {
3982   switch (e)
3983   {
3984     case FullyConnectedOptionsWeightsFormat_DEFAULT:
3985       return "DEFAULT";
3986     case FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8:
3987       return "SHUFFLED4x16INT8";
3988     case FullyConnectedOptionsWeightsFormat_SHUFFLED16x1FLOAT32:
3989       return "SHUFFLED16x1FLOAT32";
3990     default:
3991       return "";
3992   }
3993 }
3994
3995 enum LSTMKernelType : int8_t
3996 {
3997   LSTMKernelType_FULL = 0,
3998   LSTMKernelType_BASIC = 1,
3999   LSTMKernelType_MIN = LSTMKernelType_FULL,
4000   LSTMKernelType_MAX = LSTMKernelType_BASIC
4001 };
4002
4003 inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2]
4004 {
4005   static const LSTMKernelType values[] = {LSTMKernelType_FULL, LSTMKernelType_BASIC};
4006   return values;
4007 }
4008
4009 inline const char *const *EnumNamesLSTMKernelType()
4010 {
4011   static const char *const names[3] = {"FULL", "BASIC", nullptr};
4012   return names;
4013 }
4014
4015 inline const char *EnumNameLSTMKernelType(LSTMKernelType e)
4016 {
4017   if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC))
4018     return "";
4019   const size_t index = static_cast<size_t>(e);
4020   return EnumNamesLSTMKernelType()[index];
4021 }
4022
4023 enum CombinerType : int8_t
4024 {
4025   CombinerType_SUM = 0,
4026   CombinerType_MEAN = 1,
4027   CombinerType_SQRTN = 2,
4028   CombinerType_MIN = CombinerType_SUM,
4029   CombinerType_MAX = CombinerType_SQRTN
4030 };
4031
4032 inline const CombinerType (&EnumValuesCombinerType())[3]
4033 {
4034   static const CombinerType values[] = {CombinerType_SUM, CombinerType_MEAN, CombinerType_SQRTN};
4035   return values;
4036 }
4037
4038 inline const char *const *EnumNamesCombinerType()
4039 {
4040   static const char *const names[4] = {"SUM", "MEAN", "SQRTN", nullptr};
4041   return names;
4042 }
4043
4044 inline const char *EnumNameCombinerType(CombinerType e)
4045 {
4046   if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN))
4047     return "";
4048   const size_t index = static_cast<size_t>(e);
4049   return EnumNamesCombinerType()[index];
4050 }
4051
4052 enum MirrorPadMode : int8_t
4053 {
4054   MirrorPadMode_REFLECT = 0,
4055   MirrorPadMode_SYMMETRIC = 1,
4056   MirrorPadMode_MIN = MirrorPadMode_REFLECT,
4057   MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
4058 };
4059
4060 inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2]
4061 {
4062   static const MirrorPadMode values[] = {MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC};
4063   return values;
4064 }
4065
4066 inline const char *const *EnumNamesMirrorPadMode()
4067 {
4068   static const char *const names[3] = {"REFLECT", "SYMMETRIC", nullptr};
4069   return names;
4070 }
4071
4072 inline const char *EnumNameMirrorPadMode(MirrorPadMode e)
4073 {
4074   if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC))
4075     return "";
4076   const size_t index = static_cast<size_t>(e);
4077   return EnumNamesMirrorPadMode()[index];
4078 }
4079
4080 enum CustomOptionsFormat : int8_t
4081 {
4082   CustomOptionsFormat_FLEXBUFFERS = 0,
4083   CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
4084   CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
4085 };
4086
4087 inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1]
4088 {
4089   static const CustomOptionsFormat values[] = {CustomOptionsFormat_FLEXBUFFERS};
4090   return values;
4091 }
4092
4093 inline const char *const *EnumNamesCustomOptionsFormat()
4094 {
4095   static const char *const names[2] = {"FLEXBUFFERS", nullptr};
4096   return names;
4097 }
4098
4099 inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e)
4100 {
4101   if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS))
4102     return "";
4103   const size_t index = static_cast<size_t>(e);
4104   return EnumNamesCustomOptionsFormat()[index];
4105 }
4106
4107 enum DataFormat : int8_t
4108 {
4109   DataFormat_CHANNELS_LAST = 0,
4110   DataFormat_CHANNELS_FIRST = 1,
4111   DataFormat_MIN = DataFormat_CHANNELS_LAST,
4112   DataFormat_MAX = DataFormat_CHANNELS_FIRST
4113 };
4114
4115 inline const DataFormat (&EnumValuesDataFormat())[2]
4116 {
4117   static const DataFormat values[] = {DataFormat_CHANNELS_LAST, DataFormat_CHANNELS_FIRST};
4118   return values;
4119 }
4120
4121 inline const char *const *EnumNamesDataFormat()
4122 {
4123   static const char *const names[3] = {"CHANNELS_LAST", "CHANNELS_FIRST", nullptr};
4124   return names;
4125 }
4126
4127 inline const char *EnumNameDataFormat(DataFormat e)
4128 {
4129   if (flatbuffers::IsOutRange(e, DataFormat_CHANNELS_LAST, DataFormat_CHANNELS_FIRST))
4130     return "";
4131   const size_t index = static_cast<size_t>(e);
4132   return EnumNamesDataFormat()[index];
4133 }
4134
4135 struct CustomQuantizationT : public flatbuffers::NativeTable
4136 {
4137   typedef CustomQuantization TableType;
4138   std::vector<uint8_t> custom{};
4139 };
4140
4141 struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4142 {
4143   typedef CustomQuantizationT NativeTableType;
4144   typedef CustomQuantizationBuilder Builder;
4145   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4146   {
4147     VT_CUSTOM = 4
4148   };
4149   const flatbuffers::Vector<uint8_t> *custom() const
4150   {
4151     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
4152   }
4153   bool Verify(flatbuffers::Verifier &verifier) const
4154   {
4155     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CUSTOM) &&
4156            verifier.VerifyVector(custom()) && verifier.EndTable();
4157   }
4158   CustomQuantizationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4159   void UnPackTo(CustomQuantizationT *_o,
4160                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4161   static flatbuffers::Offset<CustomQuantization>
4162   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o,
4163        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4164 };
4165
4166 struct CustomQuantizationBuilder
4167 {
4168   typedef CustomQuantization Table;
4169   flatbuffers::FlatBufferBuilder &fbb_;
4170   flatbuffers::uoffset_t start_;
4171   void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom)
4172   {
4173     fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
4174   }
4175   explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4176   {
4177     start_ = fbb_.StartTable();
4178   }
4179   flatbuffers::Offset<CustomQuantization> Finish()
4180   {
4181     const auto end = fbb_.EndTable(start_);
4182     auto o = flatbuffers::Offset<CustomQuantization>(end);
4183     return o;
4184   }
4185 };
4186
4187 inline flatbuffers::Offset<CustomQuantization>
4188 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb,
4189                          flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0)
4190 {
4191   CustomQuantizationBuilder builder_(_fbb);
4192   builder_.add_custom(custom);
4193   return builder_.Finish();
4194 }
4195
4196 inline flatbuffers::Offset<CustomQuantization>
4197 CreateCustomQuantizationDirect(flatbuffers::FlatBufferBuilder &_fbb,
4198                                const std::vector<uint8_t> *custom = nullptr)
4199 {
4200   if (custom)
4201   {
4202     _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16);
4203   }
4204   auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
4205   return circle::CreateCustomQuantization(_fbb, custom__);
4206 }
4207
4208 flatbuffers::Offset<CustomQuantization>
4209 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o,
4210                          const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4211
4212 struct QuantizationParametersT : public flatbuffers::NativeTable
4213 {
4214   typedef QuantizationParameters TableType;
4215   std::vector<float> min{};
4216   std::vector<float> max{};
4217   std::vector<float> scale{};
4218   std::vector<int64_t> zero_point{};
4219   circle::QuantizationDetailsUnion details{};
4220   int32_t quantized_dimension = 0;
4221 };
4222
4223 struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4224 {
4225   typedef QuantizationParametersT NativeTableType;
4226   typedef QuantizationParametersBuilder Builder;
4227   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4228   {
4229     VT_MIN = 4,
4230     VT_MAX = 6,
4231     VT_SCALE = 8,
4232     VT_ZERO_POINT = 10,
4233     VT_DETAILS_TYPE = 12,
4234     VT_DETAILS = 14,
4235     VT_QUANTIZED_DIMENSION = 16
4236   };
4237   const flatbuffers::Vector<float> *min() const
4238   {
4239     return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
4240   }
4241   const flatbuffers::Vector<float> *max() const
4242   {
4243     return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
4244   }
4245   const flatbuffers::Vector<float> *scale() const
4246   {
4247     return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
4248   }
4249   const flatbuffers::Vector<int64_t> *zero_point() const
4250   {
4251     return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
4252   }
4253   circle::QuantizationDetails details_type() const
4254   {
4255     return static_cast<circle::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
4256   }
4257   const void *details() const { return GetPointer<const void *>(VT_DETAILS); }
4258   template <typename T> const T *details_as() const;
4259   const circle::CustomQuantization *details_as_CustomQuantization() const
4260   {
4261     return details_type() == circle::QuantizationDetails_CustomQuantization
4262              ? static_cast<const circle::CustomQuantization *>(details())
4263              : nullptr;
4264   }
4265   int32_t quantized_dimension() const { return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0); }
4266   bool Verify(flatbuffers::Verifier &verifier) const
4267   {
4268     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_MIN) &&
4269            verifier.VerifyVector(min()) && VerifyOffset(verifier, VT_MAX) &&
4270            verifier.VerifyVector(max()) && VerifyOffset(verifier, VT_SCALE) &&
4271            verifier.VerifyVector(scale()) && VerifyOffset(verifier, VT_ZERO_POINT) &&
4272            verifier.VerifyVector(zero_point()) && VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
4273            VerifyOffset(verifier, VT_DETAILS) &&
4274            VerifyQuantizationDetails(verifier, details(), details_type()) &&
4275            VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) && verifier.EndTable();
4276   }
4277   QuantizationParametersT *
4278   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4279   void UnPackTo(QuantizationParametersT *_o,
4280                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4281   static flatbuffers::Offset<QuantizationParameters>
4282   Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o,
4283        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4284 };
4285
4286 template <>
4287 inline const circle::CustomQuantization *
4288 QuantizationParameters::details_as<circle::CustomQuantization>() const
4289 {
4290   return details_as_CustomQuantization();
4291 }
4292
4293 struct QuantizationParametersBuilder
4294 {
4295   typedef QuantizationParameters Table;
4296   flatbuffers::FlatBufferBuilder &fbb_;
4297   flatbuffers::uoffset_t start_;
4298   void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min)
4299   {
4300     fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
4301   }
4302   void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max)
4303   {
4304     fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
4305   }
4306   void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale)
4307   {
4308     fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
4309   }
4310   void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point)
4311   {
4312     fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
4313   }
4314   void add_details_type(circle::QuantizationDetails details_type)
4315   {
4316     fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE,
4317                              static_cast<uint8_t>(details_type), 0);
4318   }
4319   void add_details(flatbuffers::Offset<void> details)
4320   {
4321     fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
4322   }
4323   void add_quantized_dimension(int32_t quantized_dimension)
4324   {
4325     fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension,
4326                              0);
4327   }
4328   explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4329   {
4330     start_ = fbb_.StartTable();
4331   }
4332   flatbuffers::Offset<QuantizationParameters> Finish()
4333   {
4334     const auto end = fbb_.EndTable(start_);
4335     auto o = flatbuffers::Offset<QuantizationParameters>(end);
4336     return o;
4337   }
4338 };
4339
4340 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
4341   flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
4342   flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
4343   flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
4344   flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
4345   circle::QuantizationDetails details_type = circle::QuantizationDetails_NONE,
4346   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
4347 {
4348   QuantizationParametersBuilder builder_(_fbb);
4349   builder_.add_quantized_dimension(quantized_dimension);
4350   builder_.add_details(details);
4351   builder_.add_zero_point(zero_point);
4352   builder_.add_scale(scale);
4353   builder_.add_max(max);
4354   builder_.add_min(min);
4355   builder_.add_details_type(details_type);
4356   return builder_.Finish();
4357 }
4358
4359 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
4360   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<float> *min = nullptr,
4361   const std::vector<float> *max = nullptr, const std::vector<float> *scale = nullptr,
4362   const std::vector<int64_t> *zero_point = nullptr,
4363   circle::QuantizationDetails details_type = circle::QuantizationDetails_NONE,
4364   flatbuffers::Offset<void> details = 0, int32_t quantized_dimension = 0)
4365 {
4366   auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
4367   auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
4368   auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
4369   auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
4370   return circle::CreateQuantizationParameters(_fbb, min__, max__, scale__, zero_point__,
4371                                               details_type, details, quantized_dimension);
4372 }
4373
4374 flatbuffers::Offset<QuantizationParameters>
4375 CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb,
4376                              const QuantizationParametersT *_o,
4377                              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4378
4379 struct Int32VectorT : public flatbuffers::NativeTable
4380 {
4381   typedef Int32Vector TableType;
4382   std::vector<int32_t> values{};
4383 };
4384
4385 struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4386 {
4387   typedef Int32VectorT NativeTableType;
4388   typedef Int32VectorBuilder Builder;
4389   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4390   {
4391     VT_VALUES = 4
4392   };
4393   const flatbuffers::Vector<int32_t> *values() const
4394   {
4395     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
4396   }
4397   bool Verify(flatbuffers::Verifier &verifier) const
4398   {
4399     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
4400            verifier.VerifyVector(values()) && verifier.EndTable();
4401   }
4402   Int32VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4403   void UnPackTo(Int32VectorT *_o,
4404                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4405   static flatbuffers::Offset<Int32Vector>
4406   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o,
4407        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4408 };
4409
4410 struct Int32VectorBuilder
4411 {
4412   typedef Int32Vector Table;
4413   flatbuffers::FlatBufferBuilder &fbb_;
4414   flatbuffers::uoffset_t start_;
4415   void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values)
4416   {
4417     fbb_.AddOffset(Int32Vector::VT_VALUES, values);
4418   }
4419   explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4420   {
4421     start_ = fbb_.StartTable();
4422   }
4423   flatbuffers::Offset<Int32Vector> Finish()
4424   {
4425     const auto end = fbb_.EndTable(start_);
4426     auto o = flatbuffers::Offset<Int32Vector>(end);
4427     return o;
4428   }
4429 };
4430
4431 inline flatbuffers::Offset<Int32Vector>
4432 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb,
4433                   flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0)
4434 {
4435   Int32VectorBuilder builder_(_fbb);
4436   builder_.add_values(values);
4437   return builder_.Finish();
4438 }
4439
4440 inline flatbuffers::Offset<Int32Vector>
4441 CreateInt32VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
4442                         const std::vector<int32_t> *values = nullptr)
4443 {
4444   auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
4445   return circle::CreateInt32Vector(_fbb, values__);
4446 }
4447
4448 flatbuffers::Offset<Int32Vector>
4449 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o,
4450                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4451
4452 struct Uint16VectorT : public flatbuffers::NativeTable
4453 {
4454   typedef Uint16Vector TableType;
4455   std::vector<uint16_t> values{};
4456 };
4457
4458 struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4459 {
4460   typedef Uint16VectorT NativeTableType;
4461   typedef Uint16VectorBuilder Builder;
4462   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4463   {
4464     VT_VALUES = 4
4465   };
4466   const flatbuffers::Vector<uint16_t> *values() const
4467   {
4468     return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
4469   }
4470   bool Verify(flatbuffers::Verifier &verifier) const
4471   {
4472     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
4473            verifier.VerifyVector(values()) && verifier.EndTable();
4474   }
4475   Uint16VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4476   void UnPackTo(Uint16VectorT *_o,
4477                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4478   static flatbuffers::Offset<Uint16Vector>
4479   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o,
4480        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4481 };
4482
4483 struct Uint16VectorBuilder
4484 {
4485   typedef Uint16Vector Table;
4486   flatbuffers::FlatBufferBuilder &fbb_;
4487   flatbuffers::uoffset_t start_;
4488   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values)
4489   {
4490     fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
4491   }
4492   explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4493   {
4494     start_ = fbb_.StartTable();
4495   }
4496   flatbuffers::Offset<Uint16Vector> Finish()
4497   {
4498     const auto end = fbb_.EndTable(start_);
4499     auto o = flatbuffers::Offset<Uint16Vector>(end);
4500     return o;
4501   }
4502 };
4503
4504 inline flatbuffers::Offset<Uint16Vector>
4505 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb,
4506                    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0)
4507 {
4508   Uint16VectorBuilder builder_(_fbb);
4509   builder_.add_values(values);
4510   return builder_.Finish();
4511 }
4512
4513 inline flatbuffers::Offset<Uint16Vector>
4514 CreateUint16VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
4515                          const std::vector<uint16_t> *values = nullptr)
4516 {
4517   if (values)
4518   {
4519     _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4);
4520   }
4521   auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
4522   return circle::CreateUint16Vector(_fbb, values__);
4523 }
4524
4525 flatbuffers::Offset<Uint16Vector>
4526 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o,
4527                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4528
4529 struct Uint8VectorT : public flatbuffers::NativeTable
4530 {
4531   typedef Uint8Vector TableType;
4532   std::vector<uint8_t> values{};
4533 };
4534
4535 struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4536 {
4537   typedef Uint8VectorT NativeTableType;
4538   typedef Uint8VectorBuilder Builder;
4539   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4540   {
4541     VT_VALUES = 4
4542   };
4543   const flatbuffers::Vector<uint8_t> *values() const
4544   {
4545     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
4546   }
4547   bool Verify(flatbuffers::Verifier &verifier) const
4548   {
4549     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VALUES) &&
4550            verifier.VerifyVector(values()) && verifier.EndTable();
4551   }
4552   Uint8VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4553   void UnPackTo(Uint8VectorT *_o,
4554                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4555   static flatbuffers::Offset<Uint8Vector>
4556   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o,
4557        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4558 };
4559
4560 struct Uint8VectorBuilder
4561 {
4562   typedef Uint8Vector Table;
4563   flatbuffers::FlatBufferBuilder &fbb_;
4564   flatbuffers::uoffset_t start_;
4565   void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values)
4566   {
4567     fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
4568   }
4569   explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4570   {
4571     start_ = fbb_.StartTable();
4572   }
4573   flatbuffers::Offset<Uint8Vector> Finish()
4574   {
4575     const auto end = fbb_.EndTable(start_);
4576     auto o = flatbuffers::Offset<Uint8Vector>(end);
4577     return o;
4578   }
4579 };
4580
4581 inline flatbuffers::Offset<Uint8Vector>
4582 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb,
4583                   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0)
4584 {
4585   Uint8VectorBuilder builder_(_fbb);
4586   builder_.add_values(values);
4587   return builder_.Finish();
4588 }
4589
4590 inline flatbuffers::Offset<Uint8Vector>
4591 CreateUint8VectorDirect(flatbuffers::FlatBufferBuilder &_fbb,
4592                         const std::vector<uint8_t> *values = nullptr)
4593 {
4594   if (values)
4595   {
4596     _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4);
4597   }
4598   auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
4599   return circle::CreateUint8Vector(_fbb, values__);
4600 }
4601
4602 flatbuffers::Offset<Uint8Vector>
4603 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o,
4604                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4605
4606 struct DimensionMetadataT : public flatbuffers::NativeTable
4607 {
4608   typedef DimensionMetadata TableType;
4609   circle::DimensionType format = circle::DimensionType_DENSE;
4610   int32_t dense_size = 0;
4611   circle::SparseIndexVectorUnion array_segments{};
4612   circle::SparseIndexVectorUnion array_indices{};
4613 };
4614
4615 struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4616 {
4617   typedef DimensionMetadataT NativeTableType;
4618   typedef DimensionMetadataBuilder Builder;
4619   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4620   {
4621     VT_FORMAT = 4,
4622     VT_DENSE_SIZE = 6,
4623     VT_ARRAY_SEGMENTS_TYPE = 8,
4624     VT_ARRAY_SEGMENTS = 10,
4625     VT_ARRAY_INDICES_TYPE = 12,
4626     VT_ARRAY_INDICES = 14
4627   };
4628   circle::DimensionType format() const
4629   {
4630     return static_cast<circle::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
4631   }
4632   int32_t dense_size() const { return GetField<int32_t>(VT_DENSE_SIZE, 0); }
4633   circle::SparseIndexVector array_segments_type() const
4634   {
4635     return static_cast<circle::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
4636   }
4637   const void *array_segments() const { return GetPointer<const void *>(VT_ARRAY_SEGMENTS); }
4638   template <typename T> const T *array_segments_as() const;
4639   const circle::Int32Vector *array_segments_as_Int32Vector() const
4640   {
4641     return array_segments_type() == circle::SparseIndexVector_Int32Vector
4642              ? static_cast<const circle::Int32Vector *>(array_segments())
4643              : nullptr;
4644   }
4645   const circle::Uint16Vector *array_segments_as_Uint16Vector() const
4646   {
4647     return array_segments_type() == circle::SparseIndexVector_Uint16Vector
4648              ? static_cast<const circle::Uint16Vector *>(array_segments())
4649              : nullptr;
4650   }
4651   const circle::Uint8Vector *array_segments_as_Uint8Vector() const
4652   {
4653     return array_segments_type() == circle::SparseIndexVector_Uint8Vector
4654              ? static_cast<const circle::Uint8Vector *>(array_segments())
4655              : nullptr;
4656   }
4657   circle::SparseIndexVector array_indices_type() const
4658   {
4659     return static_cast<circle::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
4660   }
4661   const void *array_indices() const { return GetPointer<const void *>(VT_ARRAY_INDICES); }
4662   template <typename T> const T *array_indices_as() const;
4663   const circle::Int32Vector *array_indices_as_Int32Vector() const
4664   {
4665     return array_indices_type() == circle::SparseIndexVector_Int32Vector
4666              ? static_cast<const circle::Int32Vector *>(array_indices())
4667              : nullptr;
4668   }
4669   const circle::Uint16Vector *array_indices_as_Uint16Vector() const
4670   {
4671     return array_indices_type() == circle::SparseIndexVector_Uint16Vector
4672              ? static_cast<const circle::Uint16Vector *>(array_indices())
4673              : nullptr;
4674   }
4675   const circle::Uint8Vector *array_indices_as_Uint8Vector() const
4676   {
4677     return array_indices_type() == circle::SparseIndexVector_Uint8Vector
4678              ? static_cast<const circle::Uint8Vector *>(array_indices())
4679              : nullptr;
4680   }
4681   bool Verify(flatbuffers::Verifier &verifier) const
4682   {
4683     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_FORMAT) &&
4684            VerifyField<int32_t>(verifier, VT_DENSE_SIZE) &&
4685            VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE) &&
4686            VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
4687            VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
4688            VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE) &&
4689            VerifyOffset(verifier, VT_ARRAY_INDICES) &&
4690            VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
4691            verifier.EndTable();
4692   }
4693   DimensionMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4694   void UnPackTo(DimensionMetadataT *_o,
4695                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4696   static flatbuffers::Offset<DimensionMetadata>
4697   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o,
4698        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4699 };
4700
4701 template <>
4702 inline const circle::Int32Vector *DimensionMetadata::array_segments_as<circle::Int32Vector>() const
4703 {
4704   return array_segments_as_Int32Vector();
4705 }
4706
4707 template <>
4708 inline const circle::Uint16Vector *
4709 DimensionMetadata::array_segments_as<circle::Uint16Vector>() const
4710 {
4711   return array_segments_as_Uint16Vector();
4712 }
4713
4714 template <>
4715 inline const circle::Uint8Vector *DimensionMetadata::array_segments_as<circle::Uint8Vector>() const
4716 {
4717   return array_segments_as_Uint8Vector();
4718 }
4719
4720 template <>
4721 inline const circle::Int32Vector *DimensionMetadata::array_indices_as<circle::Int32Vector>() const
4722 {
4723   return array_indices_as_Int32Vector();
4724 }
4725
4726 template <>
4727 inline const circle::Uint16Vector *DimensionMetadata::array_indices_as<circle::Uint16Vector>() const
4728 {
4729   return array_indices_as_Uint16Vector();
4730 }
4731
4732 template <>
4733 inline const circle::Uint8Vector *DimensionMetadata::array_indices_as<circle::Uint8Vector>() const
4734 {
4735   return array_indices_as_Uint8Vector();
4736 }
4737
4738 struct DimensionMetadataBuilder
4739 {
4740   typedef DimensionMetadata Table;
4741   flatbuffers::FlatBufferBuilder &fbb_;
4742   flatbuffers::uoffset_t start_;
4743   void add_format(circle::DimensionType format)
4744   {
4745     fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
4746   }
4747   void add_dense_size(int32_t dense_size)
4748   {
4749     fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
4750   }
4751   void add_array_segments_type(circle::SparseIndexVector array_segments_type)
4752   {
4753     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE,
4754                              static_cast<uint8_t>(array_segments_type), 0);
4755   }
4756   void add_array_segments(flatbuffers::Offset<void> array_segments)
4757   {
4758     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
4759   }
4760   void add_array_indices_type(circle::SparseIndexVector array_indices_type)
4761   {
4762     fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE,
4763                              static_cast<uint8_t>(array_indices_type), 0);
4764   }
4765   void add_array_indices(flatbuffers::Offset<void> array_indices)
4766   {
4767     fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
4768   }
4769   explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4770   {
4771     start_ = fbb_.StartTable();
4772   }
4773   flatbuffers::Offset<DimensionMetadata> Finish()
4774   {
4775     const auto end = fbb_.EndTable(start_);
4776     auto o = flatbuffers::Offset<DimensionMetadata>(end);
4777     return o;
4778   }
4779 };
4780
4781 inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
4782   flatbuffers::FlatBufferBuilder &_fbb, circle::DimensionType format = circle::DimensionType_DENSE,
4783   int32_t dense_size = 0,
4784   circle::SparseIndexVector array_segments_type = circle::SparseIndexVector_NONE,
4785   flatbuffers::Offset<void> array_segments = 0,
4786   circle::SparseIndexVector array_indices_type = circle::SparseIndexVector_NONE,
4787   flatbuffers::Offset<void> array_indices = 0)
4788 {
4789   DimensionMetadataBuilder builder_(_fbb);
4790   builder_.add_array_indices(array_indices);
4791   builder_.add_array_segments(array_segments);
4792   builder_.add_dense_size(dense_size);
4793   builder_.add_array_indices_type(array_indices_type);
4794   builder_.add_array_segments_type(array_segments_type);
4795   builder_.add_format(format);
4796   return builder_.Finish();
4797 }
4798
4799 flatbuffers::Offset<DimensionMetadata>
4800 CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o,
4801                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4802
4803 struct SparsityParametersT : public flatbuffers::NativeTable
4804 {
4805   typedef SparsityParameters TableType;
4806   std::vector<int32_t> traversal_order{};
4807   std::vector<int32_t> block_map{};
4808   std::vector<std::unique_ptr<circle::DimensionMetadataT>> dim_metadata{};
4809 };
4810
4811 struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4812 {
4813   typedef SparsityParametersT NativeTableType;
4814   typedef SparsityParametersBuilder Builder;
4815   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4816   {
4817     VT_TRAVERSAL_ORDER = 4,
4818     VT_BLOCK_MAP = 6,
4819     VT_DIM_METADATA = 8
4820   };
4821   const flatbuffers::Vector<int32_t> *traversal_order() const
4822   {
4823     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
4824   }
4825   const flatbuffers::Vector<int32_t> *block_map() const
4826   {
4827     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
4828   }
4829   const flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>> *dim_metadata() const
4830   {
4831     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>> *>(
4832       VT_DIM_METADATA);
4833   }
4834   bool Verify(flatbuffers::Verifier &verifier) const
4835   {
4836     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
4837            verifier.VerifyVector(traversal_order()) && VerifyOffset(verifier, VT_BLOCK_MAP) &&
4838            verifier.VerifyVector(block_map()) && VerifyOffset(verifier, VT_DIM_METADATA) &&
4839            verifier.VerifyVector(dim_metadata()) && verifier.VerifyVectorOfTables(dim_metadata()) &&
4840            verifier.EndTable();
4841   }
4842   SparsityParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4843   void UnPackTo(SparsityParametersT *_o,
4844                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4845   static flatbuffers::Offset<SparsityParameters>
4846   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o,
4847        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4848 };
4849
4850 struct SparsityParametersBuilder
4851 {
4852   typedef SparsityParameters Table;
4853   flatbuffers::FlatBufferBuilder &fbb_;
4854   flatbuffers::uoffset_t start_;
4855   void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order)
4856   {
4857     fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
4858   }
4859   void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map)
4860   {
4861     fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
4862   }
4863   void add_dim_metadata(
4864     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>>>
4865       dim_metadata)
4866   {
4867     fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
4868   }
4869   explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
4870   {
4871     start_ = fbb_.StartTable();
4872   }
4873   flatbuffers::Offset<SparsityParameters> Finish()
4874   {
4875     const auto end = fbb_.EndTable(start_);
4876     auto o = flatbuffers::Offset<SparsityParameters>(end);
4877     return o;
4878   }
4879 };
4880
4881 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
4882   flatbuffers::FlatBufferBuilder &_fbb,
4883   flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
4884   flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
4885   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>>>
4886     dim_metadata = 0)
4887 {
4888   SparsityParametersBuilder builder_(_fbb);
4889   builder_.add_dim_metadata(dim_metadata);
4890   builder_.add_block_map(block_map);
4891   builder_.add_traversal_order(traversal_order);
4892   return builder_.Finish();
4893 }
4894
4895 inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
4896   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *traversal_order = nullptr,
4897   const std::vector<int32_t> *block_map = nullptr,
4898   const std::vector<flatbuffers::Offset<circle::DimensionMetadata>> *dim_metadata = nullptr)
4899 {
4900   auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
4901   auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
4902   auto dim_metadata__ =
4903     dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<circle::DimensionMetadata>>(*dim_metadata)
4904                  : 0;
4905   return circle::CreateSparsityParameters(_fbb, traversal_order__, block_map__, dim_metadata__);
4906 }
4907
4908 flatbuffers::Offset<SparsityParameters>
4909 CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o,
4910                          const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4911
4912 struct TensorT : public flatbuffers::NativeTable
4913 {
4914   typedef Tensor TableType;
4915   std::vector<int32_t> shape{};
4916   circle::TensorType type = circle::TensorType_FLOAT32;
4917   uint32_t buffer = 0;
4918   std::string name{};
4919   std::unique_ptr<circle::QuantizationParametersT> quantization{};
4920   bool is_variable = false;
4921   std::unique_ptr<circle::SparsityParametersT> sparsity{};
4922   std::vector<int32_t> shape_signature{};
4923 };
4924
4925 struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
4926 {
4927   typedef TensorT NativeTableType;
4928   typedef TensorBuilder Builder;
4929   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
4930   {
4931     VT_SHAPE = 4,
4932     VT_TYPE = 6,
4933     VT_BUFFER = 8,
4934     VT_NAME = 10,
4935     VT_QUANTIZATION = 12,
4936     VT_IS_VARIABLE = 14,
4937     VT_SPARSITY = 16,
4938     VT_SHAPE_SIGNATURE = 18
4939   };
4940   const flatbuffers::Vector<int32_t> *shape() const
4941   {
4942     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
4943   }
4944   circle::TensorType type() const
4945   {
4946     return static_cast<circle::TensorType>(GetField<int8_t>(VT_TYPE, 0));
4947   }
4948   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
4949   const flatbuffers::String *name() const
4950   {
4951     return GetPointer<const flatbuffers::String *>(VT_NAME);
4952   }
4953   const circle::QuantizationParameters *quantization() const
4954   {
4955     return GetPointer<const circle::QuantizationParameters *>(VT_QUANTIZATION);
4956   }
4957   bool is_variable() const { return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0; }
4958   const circle::SparsityParameters *sparsity() const
4959   {
4960     return GetPointer<const circle::SparsityParameters *>(VT_SPARSITY);
4961   }
4962   const flatbuffers::Vector<int32_t> *shape_signature() const
4963   {
4964     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
4965   }
4966   bool Verify(flatbuffers::Verifier &verifier) const
4967   {
4968     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPE) &&
4969            verifier.VerifyVector(shape()) && VerifyField<int8_t>(verifier, VT_TYPE) &&
4970            VerifyField<uint32_t>(verifier, VT_BUFFER) && VerifyOffset(verifier, VT_NAME) &&
4971            verifier.VerifyString(name()) && VerifyOffset(verifier, VT_QUANTIZATION) &&
4972            verifier.VerifyTable(quantization()) && VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) &&
4973            VerifyOffset(verifier, VT_SPARSITY) && verifier.VerifyTable(sparsity()) &&
4974            VerifyOffset(verifier, VT_SHAPE_SIGNATURE) && verifier.VerifyVector(shape_signature()) &&
4975            verifier.EndTable();
4976   }
4977   TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4978   void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4979   static flatbuffers::Offset<Tensor>
4980   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o,
4981        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4982 };
4983
4984 struct TensorBuilder
4985 {
4986   typedef Tensor Table;
4987   flatbuffers::FlatBufferBuilder &fbb_;
4988   flatbuffers::uoffset_t start_;
4989   void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape)
4990   {
4991     fbb_.AddOffset(Tensor::VT_SHAPE, shape);
4992   }
4993   void add_type(circle::TensorType type)
4994   {
4995     fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
4996   }
4997   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0); }
4998   void add_name(flatbuffers::Offset<flatbuffers::String> name)
4999   {
5000     fbb_.AddOffset(Tensor::VT_NAME, name);
5001   }
5002   void add_quantization(flatbuffers::Offset<circle::QuantizationParameters> quantization)
5003   {
5004     fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
5005   }
5006   void add_is_variable(bool is_variable)
5007   {
5008     fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
5009   }
5010   void add_sparsity(flatbuffers::Offset<circle::SparsityParameters> sparsity)
5011   {
5012     fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
5013   }
5014   void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature)
5015   {
5016     fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
5017   }
5018   explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5019   {
5020     start_ = fbb_.StartTable();
5021   }
5022   flatbuffers::Offset<Tensor> Finish()
5023   {
5024     const auto end = fbb_.EndTable(start_);
5025     auto o = flatbuffers::Offset<Tensor>(end);
5026     return o;
5027   }
5028 };
5029
5030 inline flatbuffers::Offset<Tensor>
5031 CreateTensor(flatbuffers::FlatBufferBuilder &_fbb,
5032              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
5033              circle::TensorType type = circle::TensorType_FLOAT32, uint32_t buffer = 0,
5034              flatbuffers::Offset<flatbuffers::String> name = 0,
5035              flatbuffers::Offset<circle::QuantizationParameters> quantization = 0,
5036              bool is_variable = false, flatbuffers::Offset<circle::SparsityParameters> sparsity = 0,
5037              flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0)
5038 {
5039   TensorBuilder builder_(_fbb);
5040   builder_.add_shape_signature(shape_signature);
5041   builder_.add_sparsity(sparsity);
5042   builder_.add_quantization(quantization);
5043   builder_.add_name(name);
5044   builder_.add_buffer(buffer);
5045   builder_.add_shape(shape);
5046   builder_.add_is_variable(is_variable);
5047   builder_.add_type(type);
5048   return builder_.Finish();
5049 }
5050
5051 inline flatbuffers::Offset<Tensor> CreateTensorDirect(
5052   flatbuffers::FlatBufferBuilder &_fbb, const std::vector<int32_t> *shape = nullptr,
5053   circle::TensorType type = circle::TensorType_FLOAT32, uint32_t buffer = 0,
5054   const char *name = nullptr, flatbuffers::Offset<circle::QuantizationParameters> quantization = 0,
5055   bool is_variable = false, flatbuffers::Offset<circle::SparsityParameters> sparsity = 0,
5056   const std::vector<int32_t> *shape_signature = nullptr)
5057 {
5058   auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
5059   auto name__ = name ? _fbb.CreateString(name) : 0;
5060   auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
5061   return circle::CreateTensor(_fbb, shape__, type, buffer, name__, quantization, is_variable,
5062                               sparsity, shape_signature__);
5063 }
5064
5065 flatbuffers::Offset<Tensor>
5066 CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o,
5067              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5068
5069 struct Conv2DOptionsT : public flatbuffers::NativeTable
5070 {
5071   typedef Conv2DOptions TableType;
5072   circle::Padding padding = circle::Padding_SAME;
5073   int32_t stride_w = 0;
5074   int32_t stride_h = 0;
5075   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5076   int32_t dilation_w_factor = 1;
5077   int32_t dilation_h_factor = 1;
5078 };
5079
5080 struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5081 {
5082   typedef Conv2DOptionsT NativeTableType;
5083   typedef Conv2DOptionsBuilder Builder;
5084   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5085   {
5086     VT_PADDING = 4,
5087     VT_STRIDE_W = 6,
5088     VT_STRIDE_H = 8,
5089     VT_FUSED_ACTIVATION_FUNCTION = 10,
5090     VT_DILATION_W_FACTOR = 12,
5091     VT_DILATION_H_FACTOR = 14
5092   };
5093   circle::Padding padding() const
5094   {
5095     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
5096   }
5097   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
5098   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
5099   circle::ActivationFunctionType fused_activation_function() const
5100   {
5101     return static_cast<circle::ActivationFunctionType>(
5102       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5103   }
5104   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
5105   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
5106   bool Verify(flatbuffers::Verifier &verifier) const
5107   {
5108     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
5109            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
5110            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
5111            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5112            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
5113            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
5114   }
5115   Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5116   void UnPackTo(Conv2DOptionsT *_o,
5117                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5118   static flatbuffers::Offset<Conv2DOptions>
5119   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o,
5120        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5121 };
5122
5123 struct Conv2DOptionsBuilder
5124 {
5125   typedef Conv2DOptions Table;
5126   flatbuffers::FlatBufferBuilder &fbb_;
5127   flatbuffers::uoffset_t start_;
5128   void add_padding(circle::Padding padding)
5129   {
5130     fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5131   }
5132   void add_stride_w(int32_t stride_w)
5133   {
5134     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
5135   }
5136   void add_stride_h(int32_t stride_h)
5137   {
5138     fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
5139   }
5140   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5141   {
5142     fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
5143                             static_cast<int8_t>(fused_activation_function), 0);
5144   }
5145   void add_dilation_w_factor(int32_t dilation_w_factor)
5146   {
5147     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5148   }
5149   void add_dilation_h_factor(int32_t dilation_h_factor)
5150   {
5151     fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5152   }
5153   explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5154   {
5155     start_ = fbb_.StartTable();
5156   }
5157   flatbuffers::Offset<Conv2DOptions> Finish()
5158   {
5159     const auto end = fbb_.EndTable(start_);
5160     auto o = flatbuffers::Offset<Conv2DOptions>(end);
5161     return o;
5162   }
5163 };
5164
5165 inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
5166   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
5167   int32_t stride_w = 0, int32_t stride_h = 0,
5168   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5169   int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
5170 {
5171   Conv2DOptionsBuilder builder_(_fbb);
5172   builder_.add_dilation_h_factor(dilation_h_factor);
5173   builder_.add_dilation_w_factor(dilation_w_factor);
5174   builder_.add_stride_h(stride_h);
5175   builder_.add_stride_w(stride_w);
5176   builder_.add_fused_activation_function(fused_activation_function);
5177   builder_.add_padding(padding);
5178   return builder_.Finish();
5179 }
5180
5181 flatbuffers::Offset<Conv2DOptions>
5182 CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o,
5183                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5184
5185 struct Conv3DOptionsT : public flatbuffers::NativeTable
5186 {
5187   typedef Conv3DOptions TableType;
5188   circle::Padding padding = circle::Padding_SAME;
5189   int32_t stride_d = 0;
5190   int32_t stride_w = 0;
5191   int32_t stride_h = 0;
5192   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5193   int32_t dilation_d_factor = 1;
5194   int32_t dilation_w_factor = 1;
5195   int32_t dilation_h_factor = 1;
5196 };
5197
5198 struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5199 {
5200   typedef Conv3DOptionsT NativeTableType;
5201   typedef Conv3DOptionsBuilder Builder;
5202   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5203   {
5204     VT_PADDING = 4,
5205     VT_STRIDE_D = 6,
5206     VT_STRIDE_W = 8,
5207     VT_STRIDE_H = 10,
5208     VT_FUSED_ACTIVATION_FUNCTION = 12,
5209     VT_DILATION_D_FACTOR = 14,
5210     VT_DILATION_W_FACTOR = 16,
5211     VT_DILATION_H_FACTOR = 18
5212   };
5213   circle::Padding padding() const
5214   {
5215     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
5216   }
5217   int32_t stride_d() const { return GetField<int32_t>(VT_STRIDE_D, 0); }
5218   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
5219   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
5220   circle::ActivationFunctionType fused_activation_function() const
5221   {
5222     return static_cast<circle::ActivationFunctionType>(
5223       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5224   }
5225   int32_t dilation_d_factor() const { return GetField<int32_t>(VT_DILATION_D_FACTOR, 1); }
5226   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
5227   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
5228   bool Verify(flatbuffers::Verifier &verifier) const
5229   {
5230     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
5231            VerifyField<int32_t>(verifier, VT_STRIDE_D) &&
5232            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
5233            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
5234            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5235            VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR) &&
5236            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
5237            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
5238   }
5239   Conv3DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5240   void UnPackTo(Conv3DOptionsT *_o,
5241                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5242   static flatbuffers::Offset<Conv3DOptions>
5243   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o,
5244        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5245 };
5246
5247 struct Conv3DOptionsBuilder
5248 {
5249   typedef Conv3DOptions Table;
5250   flatbuffers::FlatBufferBuilder &fbb_;
5251   flatbuffers::uoffset_t start_;
5252   void add_padding(circle::Padding padding)
5253   {
5254     fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5255   }
5256   void add_stride_d(int32_t stride_d)
5257   {
5258     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, 0);
5259   }
5260   void add_stride_w(int32_t stride_w)
5261   {
5262     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, 0);
5263   }
5264   void add_stride_h(int32_t stride_h)
5265   {
5266     fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, 0);
5267   }
5268   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5269   {
5270     fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION,
5271                             static_cast<int8_t>(fused_activation_function), 0);
5272   }
5273   void add_dilation_d_factor(int32_t dilation_d_factor)
5274   {
5275     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, 1);
5276   }
5277   void add_dilation_w_factor(int32_t dilation_w_factor)
5278   {
5279     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5280   }
5281   void add_dilation_h_factor(int32_t dilation_h_factor)
5282   {
5283     fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5284   }
5285   explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5286   {
5287     start_ = fbb_.StartTable();
5288   }
5289   flatbuffers::Offset<Conv3DOptions> Finish()
5290   {
5291     const auto end = fbb_.EndTable(start_);
5292     auto o = flatbuffers::Offset<Conv3DOptions>(end);
5293     return o;
5294   }
5295 };
5296
5297 inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
5298   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
5299   int32_t stride_d = 0, int32_t stride_w = 0, int32_t stride_h = 0,
5300   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5301   int32_t dilation_d_factor = 1, int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
5302 {
5303   Conv3DOptionsBuilder builder_(_fbb);
5304   builder_.add_dilation_h_factor(dilation_h_factor);
5305   builder_.add_dilation_w_factor(dilation_w_factor);
5306   builder_.add_dilation_d_factor(dilation_d_factor);
5307   builder_.add_stride_h(stride_h);
5308   builder_.add_stride_w(stride_w);
5309   builder_.add_stride_d(stride_d);
5310   builder_.add_fused_activation_function(fused_activation_function);
5311   builder_.add_padding(padding);
5312   return builder_.Finish();
5313 }
5314
5315 flatbuffers::Offset<Conv3DOptions>
5316 CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o,
5317                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5318
5319 struct Pool2DOptionsT : public flatbuffers::NativeTable
5320 {
5321   typedef Pool2DOptions TableType;
5322   circle::Padding padding = circle::Padding_SAME;
5323   int32_t stride_w = 0;
5324   int32_t stride_h = 0;
5325   int32_t filter_width = 0;
5326   int32_t filter_height = 0;
5327   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5328 };
5329
5330 struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5331 {
5332   typedef Pool2DOptionsT NativeTableType;
5333   typedef Pool2DOptionsBuilder Builder;
5334   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5335   {
5336     VT_PADDING = 4,
5337     VT_STRIDE_W = 6,
5338     VT_STRIDE_H = 8,
5339     VT_FILTER_WIDTH = 10,
5340     VT_FILTER_HEIGHT = 12,
5341     VT_FUSED_ACTIVATION_FUNCTION = 14
5342   };
5343   circle::Padding padding() const
5344   {
5345     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
5346   }
5347   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
5348   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
5349   int32_t filter_width() const { return GetField<int32_t>(VT_FILTER_WIDTH, 0); }
5350   int32_t filter_height() const { return GetField<int32_t>(VT_FILTER_HEIGHT, 0); }
5351   circle::ActivationFunctionType fused_activation_function() const
5352   {
5353     return static_cast<circle::ActivationFunctionType>(
5354       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5355   }
5356   bool Verify(flatbuffers::Verifier &verifier) const
5357   {
5358     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
5359            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
5360            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
5361            VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) &&
5362            VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) &&
5363            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
5364   }
5365   Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5366   void UnPackTo(Pool2DOptionsT *_o,
5367                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5368   static flatbuffers::Offset<Pool2DOptions>
5369   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o,
5370        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5371 };
5372
5373 struct Pool2DOptionsBuilder
5374 {
5375   typedef Pool2DOptions Table;
5376   flatbuffers::FlatBufferBuilder &fbb_;
5377   flatbuffers::uoffset_t start_;
5378   void add_padding(circle::Padding padding)
5379   {
5380     fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5381   }
5382   void add_stride_w(int32_t stride_w)
5383   {
5384     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
5385   }
5386   void add_stride_h(int32_t stride_h)
5387   {
5388     fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
5389   }
5390   void add_filter_width(int32_t filter_width)
5391   {
5392     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
5393   }
5394   void add_filter_height(int32_t filter_height)
5395   {
5396     fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
5397   }
5398   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5399   {
5400     fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
5401                             static_cast<int8_t>(fused_activation_function), 0);
5402   }
5403   explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5404   {
5405     start_ = fbb_.StartTable();
5406   }
5407   flatbuffers::Offset<Pool2DOptions> Finish()
5408   {
5409     const auto end = fbb_.EndTable(start_);
5410     auto o = flatbuffers::Offset<Pool2DOptions>(end);
5411     return o;
5412   }
5413 };
5414
5415 inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
5416   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
5417   int32_t stride_w = 0, int32_t stride_h = 0, int32_t filter_width = 0, int32_t filter_height = 0,
5418   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
5419 {
5420   Pool2DOptionsBuilder builder_(_fbb);
5421   builder_.add_filter_height(filter_height);
5422   builder_.add_filter_width(filter_width);
5423   builder_.add_stride_h(stride_h);
5424   builder_.add_stride_w(stride_w);
5425   builder_.add_fused_activation_function(fused_activation_function);
5426   builder_.add_padding(padding);
5427   return builder_.Finish();
5428 }
5429
5430 flatbuffers::Offset<Pool2DOptions>
5431 CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o,
5432                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5433
5434 struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable
5435 {
5436   typedef DepthwiseConv2DOptions TableType;
5437   circle::Padding padding = circle::Padding_SAME;
5438   int32_t stride_w = 0;
5439   int32_t stride_h = 0;
5440   int32_t depth_multiplier = 0;
5441   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5442   int32_t dilation_w_factor = 1;
5443   int32_t dilation_h_factor = 1;
5444 };
5445
5446 struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5447 {
5448   typedef DepthwiseConv2DOptionsT NativeTableType;
5449   typedef DepthwiseConv2DOptionsBuilder Builder;
5450   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5451   {
5452     VT_PADDING = 4,
5453     VT_STRIDE_W = 6,
5454     VT_STRIDE_H = 8,
5455     VT_DEPTH_MULTIPLIER = 10,
5456     VT_FUSED_ACTIVATION_FUNCTION = 12,
5457     VT_DILATION_W_FACTOR = 14,
5458     VT_DILATION_H_FACTOR = 16
5459   };
5460   circle::Padding padding() const
5461   {
5462     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
5463   }
5464   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
5465   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
5466   int32_t depth_multiplier() const { return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0); }
5467   circle::ActivationFunctionType fused_activation_function() const
5468   {
5469     return static_cast<circle::ActivationFunctionType>(
5470       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5471   }
5472   int32_t dilation_w_factor() const { return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); }
5473   int32_t dilation_h_factor() const { return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); }
5474   bool Verify(flatbuffers::Verifier &verifier) const
5475   {
5476     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
5477            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
5478            VerifyField<int32_t>(verifier, VT_STRIDE_H) &&
5479            VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) &&
5480            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5481            VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) &&
5482            VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && verifier.EndTable();
5483   }
5484   DepthwiseConv2DOptionsT *
5485   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5486   void UnPackTo(DepthwiseConv2DOptionsT *_o,
5487                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5488   static flatbuffers::Offset<DepthwiseConv2DOptions>
5489   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o,
5490        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5491 };
5492
5493 struct DepthwiseConv2DOptionsBuilder
5494 {
5495   typedef DepthwiseConv2DOptions Table;
5496   flatbuffers::FlatBufferBuilder &fbb_;
5497   flatbuffers::uoffset_t start_;
5498   void add_padding(circle::Padding padding)
5499   {
5500     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5501   }
5502   void add_stride_w(int32_t stride_w)
5503   {
5504     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
5505   }
5506   void add_stride_h(int32_t stride_h)
5507   {
5508     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
5509   }
5510   void add_depth_multiplier(int32_t depth_multiplier)
5511   {
5512     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
5513   }
5514   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5515   {
5516     fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION,
5517                             static_cast<int8_t>(fused_activation_function), 0);
5518   }
5519   void add_dilation_w_factor(int32_t dilation_w_factor)
5520   {
5521     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5522   }
5523   void add_dilation_h_factor(int32_t dilation_h_factor)
5524   {
5525     fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5526   }
5527   explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5528   {
5529     start_ = fbb_.StartTable();
5530   }
5531   flatbuffers::Offset<DepthwiseConv2DOptions> Finish()
5532   {
5533     const auto end = fbb_.EndTable(start_);
5534     auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
5535     return o;
5536   }
5537 };
5538
5539 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
5540   flatbuffers::FlatBufferBuilder &_fbb, circle::Padding padding = circle::Padding_SAME,
5541   int32_t stride_w = 0, int32_t stride_h = 0, int32_t depth_multiplier = 0,
5542   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5543   int32_t dilation_w_factor = 1, int32_t dilation_h_factor = 1)
5544 {
5545   DepthwiseConv2DOptionsBuilder builder_(_fbb);
5546   builder_.add_dilation_h_factor(dilation_h_factor);
5547   builder_.add_dilation_w_factor(dilation_w_factor);
5548   builder_.add_depth_multiplier(depth_multiplier);
5549   builder_.add_stride_h(stride_h);
5550   builder_.add_stride_w(stride_w);
5551   builder_.add_fused_activation_function(fused_activation_function);
5552   builder_.add_padding(padding);
5553   return builder_.Finish();
5554 }
5555
5556 flatbuffers::Offset<DepthwiseConv2DOptions>
5557 CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb,
5558                              const DepthwiseConv2DOptionsT *_o,
5559                              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5560
5561 struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable
5562 {
5563   typedef ConcatEmbeddingsOptions TableType;
5564   int32_t num_channels = 0;
5565   std::vector<int32_t> num_columns_per_channel{};
5566   std::vector<int32_t> embedding_dim_per_channel{};
5567 };
5568
5569 struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5570 {
5571   typedef ConcatEmbeddingsOptionsT NativeTableType;
5572   typedef ConcatEmbeddingsOptionsBuilder Builder;
5573   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5574   {
5575     VT_NUM_CHANNELS = 4,
5576     VT_NUM_COLUMNS_PER_CHANNEL = 6,
5577     VT_EMBEDDING_DIM_PER_CHANNEL = 8
5578   };
5579   int32_t num_channels() const { return GetField<int32_t>(VT_NUM_CHANNELS, 0); }
5580   const flatbuffers::Vector<int32_t> *num_columns_per_channel() const
5581   {
5582     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
5583   }
5584   const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const
5585   {
5586     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
5587   }
5588   bool Verify(flatbuffers::Verifier &verifier) const
5589   {
5590     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) &&
5591            VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
5592            verifier.VerifyVector(num_columns_per_channel()) &&
5593            VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
5594            verifier.VerifyVector(embedding_dim_per_channel()) && verifier.EndTable();
5595   }
5596   ConcatEmbeddingsOptionsT *
5597   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5598   void UnPackTo(ConcatEmbeddingsOptionsT *_o,
5599                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5600   static flatbuffers::Offset<ConcatEmbeddingsOptions>
5601   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o,
5602        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5603 };
5604
5605 struct ConcatEmbeddingsOptionsBuilder
5606 {
5607   typedef ConcatEmbeddingsOptions Table;
5608   flatbuffers::FlatBufferBuilder &fbb_;
5609   flatbuffers::uoffset_t start_;
5610   void add_num_channels(int32_t num_channels)
5611   {
5612     fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
5613   }
5614   void add_num_columns_per_channel(
5615     flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel)
5616   {
5617     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
5618   }
5619   void add_embedding_dim_per_channel(
5620     flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel)
5621   {
5622     fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL,
5623                    embedding_dim_per_channel);
5624   }
5625   explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5626   {
5627     start_ = fbb_.StartTable();
5628   }
5629   flatbuffers::Offset<ConcatEmbeddingsOptions> Finish()
5630   {
5631     const auto end = fbb_.EndTable(start_);
5632     auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
5633     return o;
5634   }
5635 };
5636
5637 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
5638   flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
5639   flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
5640   flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0)
5641 {
5642   ConcatEmbeddingsOptionsBuilder builder_(_fbb);
5643   builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
5644   builder_.add_num_columns_per_channel(num_columns_per_channel);
5645   builder_.add_num_channels(num_channels);
5646   return builder_.Finish();
5647 }
5648
5649 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
5650 CreateConcatEmbeddingsOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels = 0,
5651                                     const std::vector<int32_t> *num_columns_per_channel = nullptr,
5652                                     const std::vector<int32_t> *embedding_dim_per_channel = nullptr)
5653 {
5654   auto num_columns_per_channel__ =
5655     num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
5656   auto embedding_dim_per_channel__ =
5657     embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
5658   return circle::CreateConcatEmbeddingsOptions(_fbb, num_channels, num_columns_per_channel__,
5659                                                embedding_dim_per_channel__);
5660 }
5661
5662 flatbuffers::Offset<ConcatEmbeddingsOptions>
5663 CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb,
5664                               const ConcatEmbeddingsOptionsT *_o,
5665                               const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5666
5667 struct LSHProjectionOptionsT : public flatbuffers::NativeTable
5668 {
5669   typedef LSHProjectionOptions TableType;
5670   circle::LSHProjectionType type = circle::LSHProjectionType_UNKNOWN;
5671 };
5672
5673 struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5674 {
5675   typedef LSHProjectionOptionsT NativeTableType;
5676   typedef LSHProjectionOptionsBuilder Builder;
5677   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5678   {
5679     VT_TYPE = 4
5680   };
5681   circle::LSHProjectionType type() const
5682   {
5683     return static_cast<circle::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
5684   }
5685   bool Verify(flatbuffers::Verifier &verifier) const
5686   {
5687     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_TYPE) &&
5688            verifier.EndTable();
5689   }
5690   LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5691   void UnPackTo(LSHProjectionOptionsT *_o,
5692                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5693   static flatbuffers::Offset<LSHProjectionOptions>
5694   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o,
5695        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5696 };
5697
5698 struct LSHProjectionOptionsBuilder
5699 {
5700   typedef LSHProjectionOptions Table;
5701   flatbuffers::FlatBufferBuilder &fbb_;
5702   flatbuffers::uoffset_t start_;
5703   void add_type(circle::LSHProjectionType type)
5704   {
5705     fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
5706   }
5707   explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5708   {
5709     start_ = fbb_.StartTable();
5710   }
5711   flatbuffers::Offset<LSHProjectionOptions> Finish()
5712   {
5713     const auto end = fbb_.EndTable(start_);
5714     auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
5715     return o;
5716   }
5717 };
5718
5719 inline flatbuffers::Offset<LSHProjectionOptions>
5720 CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb,
5721                            circle::LSHProjectionType type = circle::LSHProjectionType_UNKNOWN)
5722 {
5723   LSHProjectionOptionsBuilder builder_(_fbb);
5724   builder_.add_type(type);
5725   return builder_.Finish();
5726 }
5727
5728 flatbuffers::Offset<LSHProjectionOptions>
5729 CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o,
5730                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5731
5732 struct SVDFOptionsT : public flatbuffers::NativeTable
5733 {
5734   typedef SVDFOptions TableType;
5735   int32_t rank = 0;
5736   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5737   bool asymmetric_quantize_inputs = false;
5738 };
5739
5740 struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5741 {
5742   typedef SVDFOptionsT NativeTableType;
5743   typedef SVDFOptionsBuilder Builder;
5744   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5745   {
5746     VT_RANK = 4,
5747     VT_FUSED_ACTIVATION_FUNCTION = 6,
5748     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
5749   };
5750   int32_t rank() const { return GetField<int32_t>(VT_RANK, 0); }
5751   circle::ActivationFunctionType fused_activation_function() const
5752   {
5753     return static_cast<circle::ActivationFunctionType>(
5754       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5755   }
5756   bool asymmetric_quantize_inputs() const
5757   {
5758     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5759   }
5760   bool Verify(flatbuffers::Verifier &verifier) const
5761   {
5762     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RANK) &&
5763            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5764            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
5765   }
5766   SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5767   void UnPackTo(SVDFOptionsT *_o,
5768                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5769   static flatbuffers::Offset<SVDFOptions>
5770   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o,
5771        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5772 };
5773
5774 struct SVDFOptionsBuilder
5775 {
5776   typedef SVDFOptions Table;
5777   flatbuffers::FlatBufferBuilder &fbb_;
5778   flatbuffers::uoffset_t start_;
5779   void add_rank(int32_t rank) { fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0); }
5780   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5781   {
5782     fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION,
5783                             static_cast<int8_t>(fused_activation_function), 0);
5784   }
5785   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
5786   {
5787     fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
5788                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5789   }
5790   explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5791   {
5792     start_ = fbb_.StartTable();
5793   }
5794   flatbuffers::Offset<SVDFOptions> Finish()
5795   {
5796     const auto end = fbb_.EndTable(start_);
5797     auto o = flatbuffers::Offset<SVDFOptions>(end);
5798     return o;
5799   }
5800 };
5801
5802 inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
5803   flatbuffers::FlatBufferBuilder &_fbb, int32_t rank = 0,
5804   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5805   bool asymmetric_quantize_inputs = false)
5806 {
5807   SVDFOptionsBuilder builder_(_fbb);
5808   builder_.add_rank(rank);
5809   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5810   builder_.add_fused_activation_function(fused_activation_function);
5811   return builder_.Finish();
5812 }
5813
5814 flatbuffers::Offset<SVDFOptions>
5815 CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o,
5816                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5817
5818 struct RNNOptionsT : public flatbuffers::NativeTable
5819 {
5820   typedef RNNOptions TableType;
5821   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5822   bool asymmetric_quantize_inputs = false;
5823 };
5824
5825 struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5826 {
5827   typedef RNNOptionsT NativeTableType;
5828   typedef RNNOptionsBuilder Builder;
5829   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5830   {
5831     VT_FUSED_ACTIVATION_FUNCTION = 4,
5832     VT_ASYMMETRIC_QUANTIZE_INPUTS = 6
5833   };
5834   circle::ActivationFunctionType fused_activation_function() const
5835   {
5836     return static_cast<circle::ActivationFunctionType>(
5837       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5838   }
5839   bool asymmetric_quantize_inputs() const
5840   {
5841     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5842   }
5843   bool Verify(flatbuffers::Verifier &verifier) const
5844   {
5845     return VerifyTableStart(verifier) &&
5846            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5847            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
5848   }
5849   RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5850   void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5851   static flatbuffers::Offset<RNNOptions>
5852   Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o,
5853        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5854 };
5855
5856 struct RNNOptionsBuilder
5857 {
5858   typedef RNNOptions Table;
5859   flatbuffers::FlatBufferBuilder &fbb_;
5860   flatbuffers::uoffset_t start_;
5861   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5862   {
5863     fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
5864                             static_cast<int8_t>(fused_activation_function), 0);
5865   }
5866   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
5867   {
5868     fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
5869                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5870   }
5871   explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5872   {
5873     start_ = fbb_.StartTable();
5874   }
5875   flatbuffers::Offset<RNNOptions> Finish()
5876   {
5877     const auto end = fbb_.EndTable(start_);
5878     auto o = flatbuffers::Offset<RNNOptions>(end);
5879     return o;
5880   }
5881 };
5882
5883 inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
5884   flatbuffers::FlatBufferBuilder &_fbb,
5885   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5886   bool asymmetric_quantize_inputs = false)
5887 {
5888   RNNOptionsBuilder builder_(_fbb);
5889   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5890   builder_.add_fused_activation_function(fused_activation_function);
5891   return builder_.Finish();
5892 }
5893
5894 flatbuffers::Offset<RNNOptions>
5895 CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o,
5896                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5897
5898 struct SequenceRNNOptionsT : public flatbuffers::NativeTable
5899 {
5900   typedef SequenceRNNOptions TableType;
5901   bool time_major = false;
5902   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5903   bool asymmetric_quantize_inputs = false;
5904 };
5905
5906 struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5907 {
5908   typedef SequenceRNNOptionsT NativeTableType;
5909   typedef SequenceRNNOptionsBuilder Builder;
5910   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
5911   {
5912     VT_TIME_MAJOR = 4,
5913     VT_FUSED_ACTIVATION_FUNCTION = 6,
5914     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
5915   };
5916   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
5917   circle::ActivationFunctionType fused_activation_function() const
5918   {
5919     return static_cast<circle::ActivationFunctionType>(
5920       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
5921   }
5922   bool asymmetric_quantize_inputs() const
5923   {
5924     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5925   }
5926   bool Verify(flatbuffers::Verifier &verifier) const
5927   {
5928     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
5929            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
5930            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
5931   }
5932   SequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5933   void UnPackTo(SequenceRNNOptionsT *_o,
5934                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5935   static flatbuffers::Offset<SequenceRNNOptions>
5936   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o,
5937        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5938 };
5939
5940 struct SequenceRNNOptionsBuilder
5941 {
5942   typedef SequenceRNNOptions Table;
5943   flatbuffers::FlatBufferBuilder &fbb_;
5944   flatbuffers::uoffset_t start_;
5945   void add_time_major(bool time_major)
5946   {
5947     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major),
5948                              0);
5949   }
5950   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
5951   {
5952     fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
5953                             static_cast<int8_t>(fused_activation_function), 0);
5954   }
5955   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
5956   {
5957     fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
5958                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5959   }
5960   explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
5961   {
5962     start_ = fbb_.StartTable();
5963   }
5964   flatbuffers::Offset<SequenceRNNOptions> Finish()
5965   {
5966     const auto end = fbb_.EndTable(start_);
5967     auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
5968     return o;
5969   }
5970 };
5971
5972 inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
5973   flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
5974   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
5975   bool asymmetric_quantize_inputs = false)
5976 {
5977   SequenceRNNOptionsBuilder builder_(_fbb);
5978   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5979   builder_.add_fused_activation_function(fused_activation_function);
5980   builder_.add_time_major(time_major);
5981   return builder_.Finish();
5982 }
5983
5984 flatbuffers::Offset<SequenceRNNOptions>
5985 CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o,
5986                          const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5987
5988 struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable
5989 {
5990   typedef BidirectionalSequenceRNNOptions TableType;
5991   bool time_major = false;
5992   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
5993   bool merge_outputs = false;
5994   bool asymmetric_quantize_inputs = false;
5995 };
5996
5997 struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
5998 {
5999   typedef BidirectionalSequenceRNNOptionsT NativeTableType;
6000   typedef BidirectionalSequenceRNNOptionsBuilder Builder;
6001   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6002   {
6003     VT_TIME_MAJOR = 4,
6004     VT_FUSED_ACTIVATION_FUNCTION = 6,
6005     VT_MERGE_OUTPUTS = 8,
6006     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
6007   };
6008   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
6009   circle::ActivationFunctionType fused_activation_function() const
6010   {
6011     return static_cast<circle::ActivationFunctionType>(
6012       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6013   }
6014   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
6015   bool asymmetric_quantize_inputs() const
6016   {
6017     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6018   }
6019   bool Verify(flatbuffers::Verifier &verifier) const
6020   {
6021     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
6022            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6023            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
6024            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
6025   }
6026   BidirectionalSequenceRNNOptionsT *
6027   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6028   void UnPackTo(BidirectionalSequenceRNNOptionsT *_o,
6029                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6030   static flatbuffers::Offset<BidirectionalSequenceRNNOptions>
6031   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o,
6032        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6033 };
6034
6035 struct BidirectionalSequenceRNNOptionsBuilder
6036 {
6037   typedef BidirectionalSequenceRNNOptions Table;
6038   flatbuffers::FlatBufferBuilder &fbb_;
6039   flatbuffers::uoffset_t start_;
6040   void add_time_major(bool time_major)
6041   {
6042     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR,
6043                              static_cast<uint8_t>(time_major), 0);
6044   }
6045   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6046   {
6047     fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION,
6048                             static_cast<int8_t>(fused_activation_function), 0);
6049   }
6050   void add_merge_outputs(bool merge_outputs)
6051   {
6052     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS,
6053                              static_cast<uint8_t>(merge_outputs), 0);
6054   }
6055   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
6056   {
6057     fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
6058                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6059   }
6060   explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6061   {
6062     start_ = fbb_.StartTable();
6063   }
6064   flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish()
6065   {
6066     const auto end = fbb_.EndTable(start_);
6067     auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
6068     return o;
6069   }
6070 };
6071
6072 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
6073   flatbuffers::FlatBufferBuilder &_fbb, bool time_major = false,
6074   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6075   bool merge_outputs = false, bool asymmetric_quantize_inputs = false)
6076 {
6077   BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
6078   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6079   builder_.add_merge_outputs(merge_outputs);
6080   builder_.add_fused_activation_function(fused_activation_function);
6081   builder_.add_time_major(time_major);
6082   return builder_.Finish();
6083 }
6084
6085 flatbuffers::Offset<BidirectionalSequenceRNNOptions>
6086 CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb,
6087                                       const BidirectionalSequenceRNNOptionsT *_o,
6088                                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6089
6090 struct FullyConnectedOptionsT : public flatbuffers::NativeTable
6091 {
6092   typedef FullyConnectedOptions TableType;
6093   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6094   circle::FullyConnectedOptionsWeightsFormat weights_format =
6095     circle::FullyConnectedOptionsWeightsFormat_DEFAULT;
6096   bool keep_num_dims = false;
6097   bool asymmetric_quantize_inputs = false;
6098 };
6099
6100 struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6101 {
6102   typedef FullyConnectedOptionsT NativeTableType;
6103   typedef FullyConnectedOptionsBuilder Builder;
6104   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6105   {
6106     VT_FUSED_ACTIVATION_FUNCTION = 4,
6107     VT_WEIGHTS_FORMAT = 6,
6108     VT_KEEP_NUM_DIMS = 8,
6109     VT_ASYMMETRIC_QUANTIZE_INPUTS = 10
6110   };
6111   circle::ActivationFunctionType fused_activation_function() const
6112   {
6113     return static_cast<circle::ActivationFunctionType>(
6114       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6115   }
6116   circle::FullyConnectedOptionsWeightsFormat weights_format() const
6117   {
6118     return static_cast<circle::FullyConnectedOptionsWeightsFormat>(
6119       GetField<int8_t>(VT_WEIGHTS_FORMAT, 0));
6120   }
6121   bool keep_num_dims() const { return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0; }
6122   bool asymmetric_quantize_inputs() const
6123   {
6124     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6125   }
6126   bool Verify(flatbuffers::Verifier &verifier) const
6127   {
6128     return VerifyTableStart(verifier) &&
6129            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6130            VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) &&
6131            VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS) &&
6132            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
6133   }
6134   FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6135   void UnPackTo(FullyConnectedOptionsT *_o,
6136                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6137   static flatbuffers::Offset<FullyConnectedOptions>
6138   Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o,
6139        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6140 };
6141
6142 struct FullyConnectedOptionsBuilder
6143 {
6144   typedef FullyConnectedOptions Table;
6145   flatbuffers::FlatBufferBuilder &fbb_;
6146   flatbuffers::uoffset_t start_;
6147   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6148   {
6149     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
6150                             static_cast<int8_t>(fused_activation_function), 0);
6151   }
6152   void add_weights_format(circle::FullyConnectedOptionsWeightsFormat weights_format)
6153   {
6154     fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT,
6155                             static_cast<int8_t>(weights_format), 0);
6156   }
6157   void add_keep_num_dims(bool keep_num_dims)
6158   {
6159     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS,
6160                              static_cast<uint8_t>(keep_num_dims), 0);
6161   }
6162   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
6163   {
6164     fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
6165                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6166   }
6167   explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6168   {
6169     start_ = fbb_.StartTable();
6170   }
6171   flatbuffers::Offset<FullyConnectedOptions> Finish()
6172   {
6173     const auto end = fbb_.EndTable(start_);
6174     auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
6175     return o;
6176   }
6177 };
6178
6179 inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
6180   flatbuffers::FlatBufferBuilder &_fbb,
6181   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6182   circle::FullyConnectedOptionsWeightsFormat weights_format =
6183     circle::FullyConnectedOptionsWeightsFormat_DEFAULT,
6184   bool keep_num_dims = false, bool asymmetric_quantize_inputs = false)
6185 {
6186   FullyConnectedOptionsBuilder builder_(_fbb);
6187   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6188   builder_.add_keep_num_dims(keep_num_dims);
6189   builder_.add_weights_format(weights_format);
6190   builder_.add_fused_activation_function(fused_activation_function);
6191   return builder_.Finish();
6192 }
6193
6194 flatbuffers::Offset<FullyConnectedOptions>
6195 CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o,
6196                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6197
6198 struct SoftmaxOptionsT : public flatbuffers::NativeTable
6199 {
6200   typedef SoftmaxOptions TableType;
6201   float beta = 0.0f;
6202 };
6203
6204 struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6205 {
6206   typedef SoftmaxOptionsT NativeTableType;
6207   typedef SoftmaxOptionsBuilder Builder;
6208   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6209   {
6210     VT_BETA = 4
6211   };
6212   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
6213   bool Verify(flatbuffers::Verifier &verifier) const
6214   {
6215     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_BETA) &&
6216            verifier.EndTable();
6217   }
6218   SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6219   void UnPackTo(SoftmaxOptionsT *_o,
6220                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6221   static flatbuffers::Offset<SoftmaxOptions>
6222   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o,
6223        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6224 };
6225
6226 struct SoftmaxOptionsBuilder
6227 {
6228   typedef SoftmaxOptions Table;
6229   flatbuffers::FlatBufferBuilder &fbb_;
6230   flatbuffers::uoffset_t start_;
6231   void add_beta(float beta) { fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f); }
6232   explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6233   {
6234     start_ = fbb_.StartTable();
6235   }
6236   flatbuffers::Offset<SoftmaxOptions> Finish()
6237   {
6238     const auto end = fbb_.EndTable(start_);
6239     auto o = flatbuffers::Offset<SoftmaxOptions>(end);
6240     return o;
6241   }
6242 };
6243
6244 inline flatbuffers::Offset<SoftmaxOptions>
6245 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, float beta = 0.0f)
6246 {
6247   SoftmaxOptionsBuilder builder_(_fbb);
6248   builder_.add_beta(beta);
6249   return builder_.Finish();
6250 }
6251
6252 flatbuffers::Offset<SoftmaxOptions>
6253 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o,
6254                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6255
6256 struct ConcatenationOptionsT : public flatbuffers::NativeTable
6257 {
6258   typedef ConcatenationOptions TableType;
6259   int32_t axis = 0;
6260   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6261 };
6262
6263 struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6264 {
6265   typedef ConcatenationOptionsT NativeTableType;
6266   typedef ConcatenationOptionsBuilder Builder;
6267   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6268   {
6269     VT_AXIS = 4,
6270     VT_FUSED_ACTIVATION_FUNCTION = 6
6271   };
6272   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
6273   circle::ActivationFunctionType fused_activation_function() const
6274   {
6275     return static_cast<circle::ActivationFunctionType>(
6276       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6277   }
6278   bool Verify(flatbuffers::Verifier &verifier) const
6279   {
6280     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
6281            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
6282   }
6283   ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6284   void UnPackTo(ConcatenationOptionsT *_o,
6285                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6286   static flatbuffers::Offset<ConcatenationOptions>
6287   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o,
6288        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6289 };
6290
6291 struct ConcatenationOptionsBuilder
6292 {
6293   typedef ConcatenationOptions Table;
6294   flatbuffers::FlatBufferBuilder &fbb_;
6295   flatbuffers::uoffset_t start_;
6296   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0); }
6297   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6298   {
6299     fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION,
6300                             static_cast<int8_t>(fused_activation_function), 0);
6301   }
6302   explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6303   {
6304     start_ = fbb_.StartTable();
6305   }
6306   flatbuffers::Offset<ConcatenationOptions> Finish()
6307   {
6308     const auto end = fbb_.EndTable(start_);
6309     auto o = flatbuffers::Offset<ConcatenationOptions>(end);
6310     return o;
6311   }
6312 };
6313
6314 inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
6315   flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0,
6316   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
6317 {
6318   ConcatenationOptionsBuilder builder_(_fbb);
6319   builder_.add_axis(axis);
6320   builder_.add_fused_activation_function(fused_activation_function);
6321   return builder_.Finish();
6322 }
6323
6324 flatbuffers::Offset<ConcatenationOptions>
6325 CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o,
6326                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6327
6328 struct AddOptionsT : public flatbuffers::NativeTable
6329 {
6330   typedef AddOptions TableType;
6331   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6332   bool pot_scale_int16 = true;
6333 };
6334
6335 struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6336 {
6337   typedef AddOptionsT NativeTableType;
6338   typedef AddOptionsBuilder Builder;
6339   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6340   {
6341     VT_FUSED_ACTIVATION_FUNCTION = 4,
6342     VT_POT_SCALE_INT16 = 6
6343   };
6344   circle::ActivationFunctionType fused_activation_function() const
6345   {
6346     return static_cast<circle::ActivationFunctionType>(
6347       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6348   }
6349   bool pot_scale_int16() const { return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0; }
6350   bool Verify(flatbuffers::Verifier &verifier) const
6351   {
6352     return VerifyTableStart(verifier) &&
6353            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6354            VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) && verifier.EndTable();
6355   }
6356   AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6357   void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6358   static flatbuffers::Offset<AddOptions>
6359   Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o,
6360        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6361 };
6362
6363 struct AddOptionsBuilder
6364 {
6365   typedef AddOptions Table;
6366   flatbuffers::FlatBufferBuilder &fbb_;
6367   flatbuffers::uoffset_t start_;
6368   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6369   {
6370     fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION,
6371                             static_cast<int8_t>(fused_activation_function), 0);
6372   }
6373   void add_pot_scale_int16(bool pot_scale_int16)
6374   {
6375     fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16),
6376                              1);
6377   }
6378   explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6379   {
6380     start_ = fbb_.StartTable();
6381   }
6382   flatbuffers::Offset<AddOptions> Finish()
6383   {
6384     const auto end = fbb_.EndTable(start_);
6385     auto o = flatbuffers::Offset<AddOptions>(end);
6386     return o;
6387   }
6388 };
6389
6390 inline flatbuffers::Offset<AddOptions> CreateAddOptions(
6391   flatbuffers::FlatBufferBuilder &_fbb,
6392   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6393   bool pot_scale_int16 = true)
6394 {
6395   AddOptionsBuilder builder_(_fbb);
6396   builder_.add_pot_scale_int16(pot_scale_int16);
6397   builder_.add_fused_activation_function(fused_activation_function);
6398   return builder_.Finish();
6399 }
6400
6401 flatbuffers::Offset<AddOptions>
6402 CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o,
6403                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6404
6405 struct MulOptionsT : public flatbuffers::NativeTable
6406 {
6407   typedef MulOptions TableType;
6408   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6409 };
6410
6411 struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6412 {
6413   typedef MulOptionsT NativeTableType;
6414   typedef MulOptionsBuilder Builder;
6415   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6416   {
6417     VT_FUSED_ACTIVATION_FUNCTION = 4
6418   };
6419   circle::ActivationFunctionType fused_activation_function() const
6420   {
6421     return static_cast<circle::ActivationFunctionType>(
6422       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6423   }
6424   bool Verify(flatbuffers::Verifier &verifier) const
6425   {
6426     return VerifyTableStart(verifier) &&
6427            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
6428   }
6429   MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6430   void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6431   static flatbuffers::Offset<MulOptions>
6432   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o,
6433        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6434 };
6435
6436 struct MulOptionsBuilder
6437 {
6438   typedef MulOptions Table;
6439   flatbuffers::FlatBufferBuilder &fbb_;
6440   flatbuffers::uoffset_t start_;
6441   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6442   {
6443     fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION,
6444                             static_cast<int8_t>(fused_activation_function), 0);
6445   }
6446   explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6447   {
6448     start_ = fbb_.StartTable();
6449   }
6450   flatbuffers::Offset<MulOptions> Finish()
6451   {
6452     const auto end = fbb_.EndTable(start_);
6453     auto o = flatbuffers::Offset<MulOptions>(end);
6454     return o;
6455   }
6456 };
6457
6458 inline flatbuffers::Offset<MulOptions> CreateMulOptions(
6459   flatbuffers::FlatBufferBuilder &_fbb,
6460   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
6461 {
6462   MulOptionsBuilder builder_(_fbb);
6463   builder_.add_fused_activation_function(fused_activation_function);
6464   return builder_.Finish();
6465 }
6466
6467 flatbuffers::Offset<MulOptions>
6468 CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o,
6469                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6470
6471 struct L2NormOptionsT : public flatbuffers::NativeTable
6472 {
6473   typedef L2NormOptions TableType;
6474   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6475 };
6476
6477 struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6478 {
6479   typedef L2NormOptionsT NativeTableType;
6480   typedef L2NormOptionsBuilder Builder;
6481   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6482   {
6483     VT_FUSED_ACTIVATION_FUNCTION = 4
6484   };
6485   circle::ActivationFunctionType fused_activation_function() const
6486   {
6487     return static_cast<circle::ActivationFunctionType>(
6488       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6489   }
6490   bool Verify(flatbuffers::Verifier &verifier) const
6491   {
6492     return VerifyTableStart(verifier) &&
6493            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
6494   }
6495   L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6496   void UnPackTo(L2NormOptionsT *_o,
6497                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6498   static flatbuffers::Offset<L2NormOptions>
6499   Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o,
6500        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6501 };
6502
6503 struct L2NormOptionsBuilder
6504 {
6505   typedef L2NormOptions Table;
6506   flatbuffers::FlatBufferBuilder &fbb_;
6507   flatbuffers::uoffset_t start_;
6508   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6509   {
6510     fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION,
6511                             static_cast<int8_t>(fused_activation_function), 0);
6512   }
6513   explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6514   {
6515     start_ = fbb_.StartTable();
6516   }
6517   flatbuffers::Offset<L2NormOptions> Finish()
6518   {
6519     const auto end = fbb_.EndTable(start_);
6520     auto o = flatbuffers::Offset<L2NormOptions>(end);
6521     return o;
6522   }
6523 };
6524
6525 inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
6526   flatbuffers::FlatBufferBuilder &_fbb,
6527   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
6528 {
6529   L2NormOptionsBuilder builder_(_fbb);
6530   builder_.add_fused_activation_function(fused_activation_function);
6531   return builder_.Finish();
6532 }
6533
6534 flatbuffers::Offset<L2NormOptions>
6535 CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o,
6536                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6537
6538 struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable
6539 {
6540   typedef LocalResponseNormalizationOptions TableType;
6541   int32_t radius = 0;
6542   float bias = 0.0f;
6543   float alpha = 0.0f;
6544   float beta = 0.0f;
6545 };
6546
6547 struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6548 {
6549   typedef LocalResponseNormalizationOptionsT NativeTableType;
6550   typedef LocalResponseNormalizationOptionsBuilder Builder;
6551   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6552   {
6553     VT_RADIUS = 4,
6554     VT_BIAS = 6,
6555     VT_ALPHA = 8,
6556     VT_BETA = 10
6557   };
6558   int32_t radius() const { return GetField<int32_t>(VT_RADIUS, 0); }
6559   float bias() const { return GetField<float>(VT_BIAS, 0.0f); }
6560   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
6561   float beta() const { return GetField<float>(VT_BETA, 0.0f); }
6562   bool Verify(flatbuffers::Verifier &verifier) const
6563   {
6564     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_RADIUS) &&
6565            VerifyField<float>(verifier, VT_BIAS) && VerifyField<float>(verifier, VT_ALPHA) &&
6566            VerifyField<float>(verifier, VT_BETA) && verifier.EndTable();
6567   }
6568   LocalResponseNormalizationOptionsT *
6569   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6570   void UnPackTo(LocalResponseNormalizationOptionsT *_o,
6571                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6572   static flatbuffers::Offset<LocalResponseNormalizationOptions>
6573   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o,
6574        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6575 };
6576
6577 struct LocalResponseNormalizationOptionsBuilder
6578 {
6579   typedef LocalResponseNormalizationOptions Table;
6580   flatbuffers::FlatBufferBuilder &fbb_;
6581   flatbuffers::uoffset_t start_;
6582   void add_radius(int32_t radius)
6583   {
6584     fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
6585   }
6586   void add_bias(float bias)
6587   {
6588     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
6589   }
6590   void add_alpha(float alpha)
6591   {
6592     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
6593   }
6594   void add_beta(float beta)
6595   {
6596     fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
6597   }
6598   explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6599     : fbb_(_fbb)
6600   {
6601     start_ = fbb_.StartTable();
6602   }
6603   flatbuffers::Offset<LocalResponseNormalizationOptions> Finish()
6604   {
6605     const auto end = fbb_.EndTable(start_);
6606     auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
6607     return o;
6608   }
6609 };
6610
6611 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
6612 CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t radius = 0,
6613                                         float bias = 0.0f, float alpha = 0.0f, float beta = 0.0f)
6614 {
6615   LocalResponseNormalizationOptionsBuilder builder_(_fbb);
6616   builder_.add_beta(beta);
6617   builder_.add_alpha(alpha);
6618   builder_.add_bias(bias);
6619   builder_.add_radius(radius);
6620   return builder_.Finish();
6621 }
6622
6623 flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
6624   flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o,
6625   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6626
6627 struct LSTMOptionsT : public flatbuffers::NativeTable
6628 {
6629   typedef LSTMOptions TableType;
6630   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6631   float cell_clip = 0.0f;
6632   float proj_clip = 0.0f;
6633   circle::LSTMKernelType kernel_type = circle::LSTMKernelType_FULL;
6634   bool asymmetric_quantize_inputs = false;
6635 };
6636
6637 struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6638 {
6639   typedef LSTMOptionsT NativeTableType;
6640   typedef LSTMOptionsBuilder Builder;
6641   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6642   {
6643     VT_FUSED_ACTIVATION_FUNCTION = 4,
6644     VT_CELL_CLIP = 6,
6645     VT_PROJ_CLIP = 8,
6646     VT_KERNEL_TYPE = 10,
6647     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
6648   };
6649   circle::ActivationFunctionType fused_activation_function() const
6650   {
6651     return static_cast<circle::ActivationFunctionType>(
6652       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6653   }
6654   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
6655   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
6656   circle::LSTMKernelType kernel_type() const
6657   {
6658     return static_cast<circle::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
6659   }
6660   bool asymmetric_quantize_inputs() const
6661   {
6662     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6663   }
6664   bool Verify(flatbuffers::Verifier &verifier) const
6665   {
6666     return VerifyTableStart(verifier) &&
6667            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6668            VerifyField<float>(verifier, VT_CELL_CLIP) &&
6669            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
6670            VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) &&
6671            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
6672   }
6673   LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6674   void UnPackTo(LSTMOptionsT *_o,
6675                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6676   static flatbuffers::Offset<LSTMOptions>
6677   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o,
6678        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6679 };
6680
6681 struct LSTMOptionsBuilder
6682 {
6683   typedef LSTMOptions Table;
6684   flatbuffers::FlatBufferBuilder &fbb_;
6685   flatbuffers::uoffset_t start_;
6686   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6687   {
6688     fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
6689                             static_cast<int8_t>(fused_activation_function), 0);
6690   }
6691   void add_cell_clip(float cell_clip)
6692   {
6693     fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6694   }
6695   void add_proj_clip(float proj_clip)
6696   {
6697     fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6698   }
6699   void add_kernel_type(circle::LSTMKernelType kernel_type)
6700   {
6701     fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
6702   }
6703   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
6704   {
6705     fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
6706                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6707   }
6708   explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
6709   {
6710     start_ = fbb_.StartTable();
6711   }
6712   flatbuffers::Offset<LSTMOptions> Finish()
6713   {
6714     const auto end = fbb_.EndTable(start_);
6715     auto o = flatbuffers::Offset<LSTMOptions>(end);
6716     return o;
6717   }
6718 };
6719
6720 inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
6721   flatbuffers::FlatBufferBuilder &_fbb,
6722   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6723   float cell_clip = 0.0f, float proj_clip = 0.0f,
6724   circle::LSTMKernelType kernel_type = circle::LSTMKernelType_FULL,
6725   bool asymmetric_quantize_inputs = false)
6726 {
6727   LSTMOptionsBuilder builder_(_fbb);
6728   builder_.add_proj_clip(proj_clip);
6729   builder_.add_cell_clip(cell_clip);
6730   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6731   builder_.add_kernel_type(kernel_type);
6732   builder_.add_fused_activation_function(fused_activation_function);
6733   return builder_.Finish();
6734 }
6735
6736 flatbuffers::Offset<LSTMOptions>
6737 CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o,
6738                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6739
6740 struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable
6741 {
6742   typedef UnidirectionalSequenceLSTMOptions TableType;
6743   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6744   float cell_clip = 0.0f;
6745   float proj_clip = 0.0f;
6746   bool time_major = false;
6747   bool asymmetric_quantize_inputs = false;
6748 };
6749
6750 struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6751 {
6752   typedef UnidirectionalSequenceLSTMOptionsT NativeTableType;
6753   typedef UnidirectionalSequenceLSTMOptionsBuilder Builder;
6754   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6755   {
6756     VT_FUSED_ACTIVATION_FUNCTION = 4,
6757     VT_CELL_CLIP = 6,
6758     VT_PROJ_CLIP = 8,
6759     VT_TIME_MAJOR = 10,
6760     VT_ASYMMETRIC_QUANTIZE_INPUTS = 12
6761   };
6762   circle::ActivationFunctionType fused_activation_function() const
6763   {
6764     return static_cast<circle::ActivationFunctionType>(
6765       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6766   }
6767   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
6768   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
6769   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; }
6770   bool asymmetric_quantize_inputs() const
6771   {
6772     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6773   }
6774   bool Verify(flatbuffers::Verifier &verifier) const
6775   {
6776     return VerifyTableStart(verifier) &&
6777            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6778            VerifyField<float>(verifier, VT_CELL_CLIP) &&
6779            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
6780            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
6781            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
6782   }
6783   UnidirectionalSequenceLSTMOptionsT *
6784   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6785   void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o,
6786                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6787   static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
6788   Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o,
6789        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6790 };
6791
6792 struct UnidirectionalSequenceLSTMOptionsBuilder
6793 {
6794   typedef UnidirectionalSequenceLSTMOptions Table;
6795   flatbuffers::FlatBufferBuilder &fbb_;
6796   flatbuffers::uoffset_t start_;
6797   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6798   {
6799     fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
6800                             static_cast<int8_t>(fused_activation_function), 0);
6801   }
6802   void add_cell_clip(float cell_clip)
6803   {
6804     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6805   }
6806   void add_proj_clip(float proj_clip)
6807   {
6808     fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6809   }
6810   void add_time_major(bool time_major)
6811   {
6812     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
6813                              static_cast<uint8_t>(time_major), 0);
6814   }
6815   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
6816   {
6817     fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
6818                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6819   }
6820   explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6821     : fbb_(_fbb)
6822   {
6823     start_ = fbb_.StartTable();
6824   }
6825   flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish()
6826   {
6827     const auto end = fbb_.EndTable(start_);
6828     auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
6829     return o;
6830   }
6831 };
6832
6833 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
6834 CreateUnidirectionalSequenceLSTMOptions(
6835   flatbuffers::FlatBufferBuilder &_fbb,
6836   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6837   float cell_clip = 0.0f, float proj_clip = 0.0f, bool time_major = false,
6838   bool asymmetric_quantize_inputs = false)
6839 {
6840   UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
6841   builder_.add_proj_clip(proj_clip);
6842   builder_.add_cell_clip(cell_clip);
6843   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6844   builder_.add_time_major(time_major);
6845   builder_.add_fused_activation_function(fused_activation_function);
6846   return builder_.Finish();
6847 }
6848
6849 flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
6850   flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o,
6851   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6852
6853 struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable
6854 {
6855   typedef BidirectionalSequenceLSTMOptions TableType;
6856   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
6857   float cell_clip = 0.0f;
6858   float proj_clip = 0.0f;
6859   bool merge_outputs = false;
6860   bool time_major = true;
6861   bool asymmetric_quantize_inputs = false;
6862 };
6863
6864 struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6865 {
6866   typedef BidirectionalSequenceLSTMOptionsT NativeTableType;
6867   typedef BidirectionalSequenceLSTMOptionsBuilder Builder;
6868   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6869   {
6870     VT_FUSED_ACTIVATION_FUNCTION = 4,
6871     VT_CELL_CLIP = 6,
6872     VT_PROJ_CLIP = 8,
6873     VT_MERGE_OUTPUTS = 10,
6874     VT_TIME_MAJOR = 12,
6875     VT_ASYMMETRIC_QUANTIZE_INPUTS = 14
6876   };
6877   circle::ActivationFunctionType fused_activation_function() const
6878   {
6879     return static_cast<circle::ActivationFunctionType>(
6880       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
6881   }
6882   float cell_clip() const { return GetField<float>(VT_CELL_CLIP, 0.0f); }
6883   float proj_clip() const { return GetField<float>(VT_PROJ_CLIP, 0.0f); }
6884   bool merge_outputs() const { return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; }
6885   bool time_major() const { return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0; }
6886   bool asymmetric_quantize_inputs() const
6887   {
6888     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6889   }
6890   bool Verify(flatbuffers::Verifier &verifier) const
6891   {
6892     return VerifyTableStart(verifier) &&
6893            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
6894            VerifyField<float>(verifier, VT_CELL_CLIP) &&
6895            VerifyField<float>(verifier, VT_PROJ_CLIP) &&
6896            VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) &&
6897            VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) &&
6898            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
6899   }
6900   BidirectionalSequenceLSTMOptionsT *
6901   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6902   void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o,
6903                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6904   static flatbuffers::Offset<BidirectionalSequenceLSTMOptions>
6905   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o,
6906        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6907 };
6908
6909 struct BidirectionalSequenceLSTMOptionsBuilder
6910 {
6911   typedef BidirectionalSequenceLSTMOptions Table;
6912   flatbuffers::FlatBufferBuilder &fbb_;
6913   flatbuffers::uoffset_t start_;
6914   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
6915   {
6916     fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION,
6917                             static_cast<int8_t>(fused_activation_function), 0);
6918   }
6919   void add_cell_clip(float cell_clip)
6920   {
6921     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6922   }
6923   void add_proj_clip(float proj_clip)
6924   {
6925     fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6926   }
6927   void add_merge_outputs(bool merge_outputs)
6928   {
6929     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS,
6930                              static_cast<uint8_t>(merge_outputs), 0);
6931   }
6932   void add_time_major(bool time_major)
6933   {
6934     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR,
6935                              static_cast<uint8_t>(time_major), 1);
6936   }
6937   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
6938   {
6939     fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
6940                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6941   }
6942   explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6943     : fbb_(_fbb)
6944   {
6945     start_ = fbb_.StartTable();
6946   }
6947   flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish()
6948   {
6949     const auto end = fbb_.EndTable(start_);
6950     auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
6951     return o;
6952   }
6953 };
6954
6955 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
6956   flatbuffers::FlatBufferBuilder &_fbb,
6957   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
6958   float cell_clip = 0.0f, float proj_clip = 0.0f, bool merge_outputs = false,
6959   bool time_major = true, bool asymmetric_quantize_inputs = false)
6960 {
6961   BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
6962   builder_.add_proj_clip(proj_clip);
6963   builder_.add_cell_clip(cell_clip);
6964   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6965   builder_.add_time_major(time_major);
6966   builder_.add_merge_outputs(merge_outputs);
6967   builder_.add_fused_activation_function(fused_activation_function);
6968   return builder_.Finish();
6969 }
6970
6971 flatbuffers::Offset<BidirectionalSequenceLSTMOptions>
6972 CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb,
6973                                        const BidirectionalSequenceLSTMOptionsT *_o,
6974                                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6975
6976 struct ResizeBilinearOptionsT : public flatbuffers::NativeTable
6977 {
6978   typedef ResizeBilinearOptions TableType;
6979   bool align_corners = false;
6980   bool half_pixel_centers = false;
6981 };
6982
6983 struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
6984 {
6985   typedef ResizeBilinearOptionsT NativeTableType;
6986   typedef ResizeBilinearOptionsBuilder Builder;
6987   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
6988   {
6989     VT_ALIGN_CORNERS = 8,
6990     VT_HALF_PIXEL_CENTERS = 10
6991   };
6992   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
6993   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
6994   bool Verify(flatbuffers::Verifier &verifier) const
6995   {
6996     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
6997            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
6998   }
6999   ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7000   void UnPackTo(ResizeBilinearOptionsT *_o,
7001                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7002   static flatbuffers::Offset<ResizeBilinearOptions>
7003   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o,
7004        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7005 };
7006
7007 struct ResizeBilinearOptionsBuilder
7008 {
7009   typedef ResizeBilinearOptions Table;
7010   flatbuffers::FlatBufferBuilder &fbb_;
7011   flatbuffers::uoffset_t start_;
7012   void add_align_corners(bool align_corners)
7013   {
7014     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS,
7015                              static_cast<uint8_t>(align_corners), 0);
7016   }
7017   void add_half_pixel_centers(bool half_pixel_centers)
7018   {
7019     fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS,
7020                              static_cast<uint8_t>(half_pixel_centers), 0);
7021   }
7022   explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7023   {
7024     start_ = fbb_.StartTable();
7025   }
7026   flatbuffers::Offset<ResizeBilinearOptions> Finish()
7027   {
7028     const auto end = fbb_.EndTable(start_);
7029     auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
7030     return o;
7031   }
7032 };
7033
7034 inline flatbuffers::Offset<ResizeBilinearOptions>
7035 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
7036                             bool half_pixel_centers = false)
7037 {
7038   ResizeBilinearOptionsBuilder builder_(_fbb);
7039   builder_.add_half_pixel_centers(half_pixel_centers);
7040   builder_.add_align_corners(align_corners);
7041   return builder_.Finish();
7042 }
7043
7044 flatbuffers::Offset<ResizeBilinearOptions>
7045 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o,
7046                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7047
7048 struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable
7049 {
7050   typedef ResizeNearestNeighborOptions TableType;
7051   bool align_corners = false;
7052   bool half_pixel_centers = false;
7053 };
7054
7055 struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7056 {
7057   typedef ResizeNearestNeighborOptionsT NativeTableType;
7058   typedef ResizeNearestNeighborOptionsBuilder Builder;
7059   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7060   {
7061     VT_ALIGN_CORNERS = 4,
7062     VT_HALF_PIXEL_CENTERS = 6
7063   };
7064   bool align_corners() const { return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; }
7065   bool half_pixel_centers() const { return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0; }
7066   bool Verify(flatbuffers::Verifier &verifier) const
7067   {
7068     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) &&
7069            VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS) && verifier.EndTable();
7070   }
7071   ResizeNearestNeighborOptionsT *
7072   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7073   void UnPackTo(ResizeNearestNeighborOptionsT *_o,
7074                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7075   static flatbuffers::Offset<ResizeNearestNeighborOptions>
7076   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o,
7077        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7078 };
7079
7080 struct ResizeNearestNeighborOptionsBuilder
7081 {
7082   typedef ResizeNearestNeighborOptions Table;
7083   flatbuffers::FlatBufferBuilder &fbb_;
7084   flatbuffers::uoffset_t start_;
7085   void add_align_corners(bool align_corners)
7086   {
7087     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS,
7088                              static_cast<uint8_t>(align_corners), 0);
7089   }
7090   void add_half_pixel_centers(bool half_pixel_centers)
7091   {
7092     fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS,
7093                              static_cast<uint8_t>(half_pixel_centers), 0);
7094   }
7095   explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7096   {
7097     start_ = fbb_.StartTable();
7098   }
7099   flatbuffers::Offset<ResizeNearestNeighborOptions> Finish()
7100   {
7101     const auto end = fbb_.EndTable(start_);
7102     auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
7103     return o;
7104   }
7105 };
7106
7107 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
7108 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners = false,
7109                                    bool half_pixel_centers = false)
7110 {
7111   ResizeNearestNeighborOptionsBuilder builder_(_fbb);
7112   builder_.add_half_pixel_centers(half_pixel_centers);
7113   builder_.add_align_corners(align_corners);
7114   return builder_.Finish();
7115 }
7116
7117 flatbuffers::Offset<ResizeNearestNeighborOptions>
7118 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb,
7119                                    const ResizeNearestNeighborOptionsT *_o,
7120                                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7121
7122 struct CallOptionsT : public flatbuffers::NativeTable
7123 {
7124   typedef CallOptions TableType;
7125   uint32_t subgraph = 0;
7126 };
7127
7128 struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7129 {
7130   typedef CallOptionsT NativeTableType;
7131   typedef CallOptionsBuilder Builder;
7132   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7133   {
7134     VT_SUBGRAPH = 4
7135   };
7136   uint32_t subgraph() const { return GetField<uint32_t>(VT_SUBGRAPH, 0); }
7137   bool Verify(flatbuffers::Verifier &verifier) const
7138   {
7139     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_SUBGRAPH) &&
7140            verifier.EndTable();
7141   }
7142   CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7143   void UnPackTo(CallOptionsT *_o,
7144                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7145   static flatbuffers::Offset<CallOptions>
7146   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o,
7147        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7148 };
7149
7150 struct CallOptionsBuilder
7151 {
7152   typedef CallOptions Table;
7153   flatbuffers::FlatBufferBuilder &fbb_;
7154   flatbuffers::uoffset_t start_;
7155   void add_subgraph(uint32_t subgraph)
7156   {
7157     fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
7158   }
7159   explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7160   {
7161     start_ = fbb_.StartTable();
7162   }
7163   flatbuffers::Offset<CallOptions> Finish()
7164   {
7165     const auto end = fbb_.EndTable(start_);
7166     auto o = flatbuffers::Offset<CallOptions>(end);
7167     return o;
7168   }
7169 };
7170
7171 inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb,
7172                                                           uint32_t subgraph = 0)
7173 {
7174   CallOptionsBuilder builder_(_fbb);
7175   builder_.add_subgraph(subgraph);
7176   return builder_.Finish();
7177 }
7178
7179 flatbuffers::Offset<CallOptions>
7180 CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o,
7181                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7182
7183 struct PadOptionsT : public flatbuffers::NativeTable
7184 {
7185   typedef PadOptions TableType;
7186 };
7187
7188 struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7189 {
7190   typedef PadOptionsT NativeTableType;
7191   typedef PadOptionsBuilder Builder;
7192   bool Verify(flatbuffers::Verifier &verifier) const
7193   {
7194     return VerifyTableStart(verifier) && verifier.EndTable();
7195   }
7196   PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7197   void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7198   static flatbuffers::Offset<PadOptions>
7199   Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o,
7200        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7201 };
7202
7203 struct PadOptionsBuilder
7204 {
7205   typedef PadOptions Table;
7206   flatbuffers::FlatBufferBuilder &fbb_;
7207   flatbuffers::uoffset_t start_;
7208   explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7209   {
7210     start_ = fbb_.StartTable();
7211   }
7212   flatbuffers::Offset<PadOptions> Finish()
7213   {
7214     const auto end = fbb_.EndTable(start_);
7215     auto o = flatbuffers::Offset<PadOptions>(end);
7216     return o;
7217   }
7218 };
7219
7220 inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb)
7221 {
7222   PadOptionsBuilder builder_(_fbb);
7223   return builder_.Finish();
7224 }
7225
7226 flatbuffers::Offset<PadOptions>
7227 CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o,
7228                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7229
7230 struct PadV2OptionsT : public flatbuffers::NativeTable
7231 {
7232   typedef PadV2Options TableType;
7233 };
7234
7235 struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7236 {
7237   typedef PadV2OptionsT NativeTableType;
7238   typedef PadV2OptionsBuilder Builder;
7239   bool Verify(flatbuffers::Verifier &verifier) const
7240   {
7241     return VerifyTableStart(verifier) && verifier.EndTable();
7242   }
7243   PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7244   void UnPackTo(PadV2OptionsT *_o,
7245                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7246   static flatbuffers::Offset<PadV2Options>
7247   Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o,
7248        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7249 };
7250
7251 struct PadV2OptionsBuilder
7252 {
7253   typedef PadV2Options Table;
7254   flatbuffers::FlatBufferBuilder &fbb_;
7255   flatbuffers::uoffset_t start_;
7256   explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7257   {
7258     start_ = fbb_.StartTable();
7259   }
7260   flatbuffers::Offset<PadV2Options> Finish()
7261   {
7262     const auto end = fbb_.EndTable(start_);
7263     auto o = flatbuffers::Offset<PadV2Options>(end);
7264     return o;
7265   }
7266 };
7267
7268 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7269 {
7270   PadV2OptionsBuilder builder_(_fbb);
7271   return builder_.Finish();
7272 }
7273
7274 flatbuffers::Offset<PadV2Options>
7275 CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o,
7276                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7277
7278 struct ReshapeOptionsT : public flatbuffers::NativeTable
7279 {
7280   typedef ReshapeOptions TableType;
7281   std::vector<int32_t> new_shape{};
7282 };
7283
7284 struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7285 {
7286   typedef ReshapeOptionsT NativeTableType;
7287   typedef ReshapeOptionsBuilder Builder;
7288   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7289   {
7290     VT_NEW_SHAPE = 4
7291   };
7292   const flatbuffers::Vector<int32_t> *new_shape() const
7293   {
7294     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
7295   }
7296   bool Verify(flatbuffers::Verifier &verifier) const
7297   {
7298     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NEW_SHAPE) &&
7299            verifier.VerifyVector(new_shape()) && verifier.EndTable();
7300   }
7301   ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7302   void UnPackTo(ReshapeOptionsT *_o,
7303                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7304   static flatbuffers::Offset<ReshapeOptions>
7305   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o,
7306        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7307 };
7308
7309 struct ReshapeOptionsBuilder
7310 {
7311   typedef ReshapeOptions Table;
7312   flatbuffers::FlatBufferBuilder &fbb_;
7313   flatbuffers::uoffset_t start_;
7314   void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape)
7315   {
7316     fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
7317   }
7318   explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7319   {
7320     start_ = fbb_.StartTable();
7321   }
7322   flatbuffers::Offset<ReshapeOptions> Finish()
7323   {
7324     const auto end = fbb_.EndTable(start_);
7325     auto o = flatbuffers::Offset<ReshapeOptions>(end);
7326     return o;
7327   }
7328 };
7329
7330 inline flatbuffers::Offset<ReshapeOptions>
7331 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
7332                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0)
7333 {
7334   ReshapeOptionsBuilder builder_(_fbb);
7335   builder_.add_new_shape(new_shape);
7336   return builder_.Finish();
7337 }
7338
7339 inline flatbuffers::Offset<ReshapeOptions>
7340 CreateReshapeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
7341                            const std::vector<int32_t> *new_shape = nullptr)
7342 {
7343   auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
7344   return circle::CreateReshapeOptions(_fbb, new_shape__);
7345 }
7346
7347 flatbuffers::Offset<ReshapeOptions>
7348 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o,
7349                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7350
7351 struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable
7352 {
7353   typedef SpaceToBatchNDOptions TableType;
7354 };
7355
7356 struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7357 {
7358   typedef SpaceToBatchNDOptionsT NativeTableType;
7359   typedef SpaceToBatchNDOptionsBuilder Builder;
7360   bool Verify(flatbuffers::Verifier &verifier) const
7361   {
7362     return VerifyTableStart(verifier) && verifier.EndTable();
7363   }
7364   SpaceToBatchNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7365   void UnPackTo(SpaceToBatchNDOptionsT *_o,
7366                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7367   static flatbuffers::Offset<SpaceToBatchNDOptions>
7368   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o,
7369        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7370 };
7371
7372 struct SpaceToBatchNDOptionsBuilder
7373 {
7374   typedef SpaceToBatchNDOptions Table;
7375   flatbuffers::FlatBufferBuilder &fbb_;
7376   flatbuffers::uoffset_t start_;
7377   explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7378   {
7379     start_ = fbb_.StartTable();
7380   }
7381   flatbuffers::Offset<SpaceToBatchNDOptions> Finish()
7382   {
7383     const auto end = fbb_.EndTable(start_);
7384     auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
7385     return o;
7386   }
7387 };
7388
7389 inline flatbuffers::Offset<SpaceToBatchNDOptions>
7390 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
7391 {
7392   SpaceToBatchNDOptionsBuilder builder_(_fbb);
7393   return builder_.Finish();
7394 }
7395
7396 flatbuffers::Offset<SpaceToBatchNDOptions>
7397 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o,
7398                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7399
7400 struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable
7401 {
7402   typedef BatchToSpaceNDOptions TableType;
7403 };
7404
7405 struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7406 {
7407   typedef BatchToSpaceNDOptionsT NativeTableType;
7408   typedef BatchToSpaceNDOptionsBuilder Builder;
7409   bool Verify(flatbuffers::Verifier &verifier) const
7410   {
7411     return VerifyTableStart(verifier) && verifier.EndTable();
7412   }
7413   BatchToSpaceNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7414   void UnPackTo(BatchToSpaceNDOptionsT *_o,
7415                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7416   static flatbuffers::Offset<BatchToSpaceNDOptions>
7417   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o,
7418        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7419 };
7420
7421 struct BatchToSpaceNDOptionsBuilder
7422 {
7423   typedef BatchToSpaceNDOptions Table;
7424   flatbuffers::FlatBufferBuilder &fbb_;
7425   flatbuffers::uoffset_t start_;
7426   explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7427   {
7428     start_ = fbb_.StartTable();
7429   }
7430   flatbuffers::Offset<BatchToSpaceNDOptions> Finish()
7431   {
7432     const auto end = fbb_.EndTable(start_);
7433     auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
7434     return o;
7435   }
7436 };
7437
7438 inline flatbuffers::Offset<BatchToSpaceNDOptions>
7439 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
7440 {
7441   BatchToSpaceNDOptionsBuilder builder_(_fbb);
7442   return builder_.Finish();
7443 }
7444
7445 flatbuffers::Offset<BatchToSpaceNDOptions>
7446 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o,
7447                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7448
7449 struct SkipGramOptionsT : public flatbuffers::NativeTable
7450 {
7451   typedef SkipGramOptions TableType;
7452   int32_t ngram_size = 0;
7453   int32_t max_skip_size = 0;
7454   bool include_all_ngrams = false;
7455 };
7456
7457 struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7458 {
7459   typedef SkipGramOptionsT NativeTableType;
7460   typedef SkipGramOptionsBuilder Builder;
7461   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7462   {
7463     VT_NGRAM_SIZE = 4,
7464     VT_MAX_SKIP_SIZE = 6,
7465     VT_INCLUDE_ALL_NGRAMS = 8
7466   };
7467   int32_t ngram_size() const { return GetField<int32_t>(VT_NGRAM_SIZE, 0); }
7468   int32_t max_skip_size() const { return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0); }
7469   bool include_all_ngrams() const { return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0; }
7470   bool Verify(flatbuffers::Verifier &verifier) const
7471   {
7472     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) &&
7473            VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) &&
7474            VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) && verifier.EndTable();
7475   }
7476   SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7477   void UnPackTo(SkipGramOptionsT *_o,
7478                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7479   static flatbuffers::Offset<SkipGramOptions>
7480   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o,
7481        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7482 };
7483
7484 struct SkipGramOptionsBuilder
7485 {
7486   typedef SkipGramOptions Table;
7487   flatbuffers::FlatBufferBuilder &fbb_;
7488   flatbuffers::uoffset_t start_;
7489   void add_ngram_size(int32_t ngram_size)
7490   {
7491     fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
7492   }
7493   void add_max_skip_size(int32_t max_skip_size)
7494   {
7495     fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
7496   }
7497   void add_include_all_ngrams(bool include_all_ngrams)
7498   {
7499     fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS,
7500                              static_cast<uint8_t>(include_all_ngrams), 0);
7501   }
7502   explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7503   {
7504     start_ = fbb_.StartTable();
7505   }
7506   flatbuffers::Offset<SkipGramOptions> Finish()
7507   {
7508     const auto end = fbb_.EndTable(start_);
7509     auto o = flatbuffers::Offset<SkipGramOptions>(end);
7510     return o;
7511   }
7512 };
7513
7514 inline flatbuffers::Offset<SkipGramOptions>
7515 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size = 0,
7516                       int32_t max_skip_size = 0, bool include_all_ngrams = false)
7517 {
7518   SkipGramOptionsBuilder builder_(_fbb);
7519   builder_.add_max_skip_size(max_skip_size);
7520   builder_.add_ngram_size(ngram_size);
7521   builder_.add_include_all_ngrams(include_all_ngrams);
7522   return builder_.Finish();
7523 }
7524
7525 flatbuffers::Offset<SkipGramOptions>
7526 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o,
7527                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7528
7529 struct SpaceToDepthOptionsT : public flatbuffers::NativeTable
7530 {
7531   typedef SpaceToDepthOptions TableType;
7532   int32_t block_size = 0;
7533 };
7534
7535 struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7536 {
7537   typedef SpaceToDepthOptionsT NativeTableType;
7538   typedef SpaceToDepthOptionsBuilder Builder;
7539   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7540   {
7541     VT_BLOCK_SIZE = 4
7542   };
7543   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
7544   bool Verify(flatbuffers::Verifier &verifier) const
7545   {
7546     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
7547            verifier.EndTable();
7548   }
7549   SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7550   void UnPackTo(SpaceToDepthOptionsT *_o,
7551                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7552   static flatbuffers::Offset<SpaceToDepthOptions>
7553   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o,
7554        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7555 };
7556
7557 struct SpaceToDepthOptionsBuilder
7558 {
7559   typedef SpaceToDepthOptions Table;
7560   flatbuffers::FlatBufferBuilder &fbb_;
7561   flatbuffers::uoffset_t start_;
7562   void add_block_size(int32_t block_size)
7563   {
7564     fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
7565   }
7566   explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7567   {
7568     start_ = fbb_.StartTable();
7569   }
7570   flatbuffers::Offset<SpaceToDepthOptions> Finish()
7571   {
7572     const auto end = fbb_.EndTable(start_);
7573     auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
7574     return o;
7575   }
7576 };
7577
7578 inline flatbuffers::Offset<SpaceToDepthOptions>
7579 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
7580 {
7581   SpaceToDepthOptionsBuilder builder_(_fbb);
7582   builder_.add_block_size(block_size);
7583   return builder_.Finish();
7584 }
7585
7586 flatbuffers::Offset<SpaceToDepthOptions>
7587 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o,
7588                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7589
7590 struct DepthToSpaceOptionsT : public flatbuffers::NativeTable
7591 {
7592   typedef DepthToSpaceOptions TableType;
7593   int32_t block_size = 0;
7594 };
7595
7596 struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7597 {
7598   typedef DepthToSpaceOptionsT NativeTableType;
7599   typedef DepthToSpaceOptionsBuilder Builder;
7600   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7601   {
7602     VT_BLOCK_SIZE = 4
7603   };
7604   int32_t block_size() const { return GetField<int32_t>(VT_BLOCK_SIZE, 0); }
7605   bool Verify(flatbuffers::Verifier &verifier) const
7606   {
7607     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) &&
7608            verifier.EndTable();
7609   }
7610   DepthToSpaceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7611   void UnPackTo(DepthToSpaceOptionsT *_o,
7612                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7613   static flatbuffers::Offset<DepthToSpaceOptions>
7614   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o,
7615        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7616 };
7617
7618 struct DepthToSpaceOptionsBuilder
7619 {
7620   typedef DepthToSpaceOptions Table;
7621   flatbuffers::FlatBufferBuilder &fbb_;
7622   flatbuffers::uoffset_t start_;
7623   void add_block_size(int32_t block_size)
7624   {
7625     fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
7626   }
7627   explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7628   {
7629     start_ = fbb_.StartTable();
7630   }
7631   flatbuffers::Offset<DepthToSpaceOptions> Finish()
7632   {
7633     const auto end = fbb_.EndTable(start_);
7634     auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
7635     return o;
7636   }
7637 };
7638
7639 inline flatbuffers::Offset<DepthToSpaceOptions>
7640 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size = 0)
7641 {
7642   DepthToSpaceOptionsBuilder builder_(_fbb);
7643   builder_.add_block_size(block_size);
7644   return builder_.Finish();
7645 }
7646
7647 flatbuffers::Offset<DepthToSpaceOptions>
7648 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o,
7649                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7650
7651 struct SubOptionsT : public flatbuffers::NativeTable
7652 {
7653   typedef SubOptions TableType;
7654   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
7655   bool pot_scale_int16 = true;
7656 };
7657
7658 struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7659 {
7660   typedef SubOptionsT NativeTableType;
7661   typedef SubOptionsBuilder Builder;
7662   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7663   {
7664     VT_FUSED_ACTIVATION_FUNCTION = 4,
7665     VT_POT_SCALE_INT16 = 6
7666   };
7667   circle::ActivationFunctionType fused_activation_function() const
7668   {
7669     return static_cast<circle::ActivationFunctionType>(
7670       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
7671   }
7672   bool pot_scale_int16() const { return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0; }
7673   bool Verify(flatbuffers::Verifier &verifier) const
7674   {
7675     return VerifyTableStart(verifier) &&
7676            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) &&
7677            VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16) && verifier.EndTable();
7678   }
7679   SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7680   void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7681   static flatbuffers::Offset<SubOptions>
7682   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o,
7683        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7684 };
7685
7686 struct SubOptionsBuilder
7687 {
7688   typedef SubOptions Table;
7689   flatbuffers::FlatBufferBuilder &fbb_;
7690   flatbuffers::uoffset_t start_;
7691   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
7692   {
7693     fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION,
7694                             static_cast<int8_t>(fused_activation_function), 0);
7695   }
7696   void add_pot_scale_int16(bool pot_scale_int16)
7697   {
7698     fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16),
7699                              1);
7700   }
7701   explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7702   {
7703     start_ = fbb_.StartTable();
7704   }
7705   flatbuffers::Offset<SubOptions> Finish()
7706   {
7707     const auto end = fbb_.EndTable(start_);
7708     auto o = flatbuffers::Offset<SubOptions>(end);
7709     return o;
7710   }
7711 };
7712
7713 inline flatbuffers::Offset<SubOptions> CreateSubOptions(
7714   flatbuffers::FlatBufferBuilder &_fbb,
7715   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE,
7716   bool pot_scale_int16 = true)
7717 {
7718   SubOptionsBuilder builder_(_fbb);
7719   builder_.add_pot_scale_int16(pot_scale_int16);
7720   builder_.add_fused_activation_function(fused_activation_function);
7721   return builder_.Finish();
7722 }
7723
7724 flatbuffers::Offset<SubOptions>
7725 CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o,
7726                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7727
7728 struct DivOptionsT : public flatbuffers::NativeTable
7729 {
7730   typedef DivOptions TableType;
7731   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
7732 };
7733
7734 struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7735 {
7736   typedef DivOptionsT NativeTableType;
7737   typedef DivOptionsBuilder Builder;
7738   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7739   {
7740     VT_FUSED_ACTIVATION_FUNCTION = 4
7741   };
7742   circle::ActivationFunctionType fused_activation_function() const
7743   {
7744     return static_cast<circle::ActivationFunctionType>(
7745       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
7746   }
7747   bool Verify(flatbuffers::Verifier &verifier) const
7748   {
7749     return VerifyTableStart(verifier) &&
7750            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
7751   }
7752   DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7753   void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7754   static flatbuffers::Offset<DivOptions>
7755   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o,
7756        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7757 };
7758
7759 struct DivOptionsBuilder
7760 {
7761   typedef DivOptions Table;
7762   flatbuffers::FlatBufferBuilder &fbb_;
7763   flatbuffers::uoffset_t start_;
7764   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
7765   {
7766     fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION,
7767                             static_cast<int8_t>(fused_activation_function), 0);
7768   }
7769   explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7770   {
7771     start_ = fbb_.StartTable();
7772   }
7773   flatbuffers::Offset<DivOptions> Finish()
7774   {
7775     const auto end = fbb_.EndTable(start_);
7776     auto o = flatbuffers::Offset<DivOptions>(end);
7777     return o;
7778   }
7779 };
7780
7781 inline flatbuffers::Offset<DivOptions> CreateDivOptions(
7782   flatbuffers::FlatBufferBuilder &_fbb,
7783   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
7784 {
7785   DivOptionsBuilder builder_(_fbb);
7786   builder_.add_fused_activation_function(fused_activation_function);
7787   return builder_.Finish();
7788 }
7789
7790 flatbuffers::Offset<DivOptions>
7791 CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o,
7792                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7793
7794 struct TopKV2OptionsT : public flatbuffers::NativeTable
7795 {
7796   typedef TopKV2Options TableType;
7797 };
7798
7799 struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7800 {
7801   typedef TopKV2OptionsT NativeTableType;
7802   typedef TopKV2OptionsBuilder Builder;
7803   bool Verify(flatbuffers::Verifier &verifier) const
7804   {
7805     return VerifyTableStart(verifier) && verifier.EndTable();
7806   }
7807   TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7808   void UnPackTo(TopKV2OptionsT *_o,
7809                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7810   static flatbuffers::Offset<TopKV2Options>
7811   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o,
7812        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7813 };
7814
7815 struct TopKV2OptionsBuilder
7816 {
7817   typedef TopKV2Options Table;
7818   flatbuffers::FlatBufferBuilder &fbb_;
7819   flatbuffers::uoffset_t start_;
7820   explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7821   {
7822     start_ = fbb_.StartTable();
7823   }
7824   flatbuffers::Offset<TopKV2Options> Finish()
7825   {
7826     const auto end = fbb_.EndTable(start_);
7827     auto o = flatbuffers::Offset<TopKV2Options>(end);
7828     return o;
7829   }
7830 };
7831
7832 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb)
7833 {
7834   TopKV2OptionsBuilder builder_(_fbb);
7835   return builder_.Finish();
7836 }
7837
7838 flatbuffers::Offset<TopKV2Options>
7839 CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o,
7840                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7841
7842 struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable
7843 {
7844   typedef EmbeddingLookupSparseOptions TableType;
7845   circle::CombinerType combiner = circle::CombinerType_SUM;
7846 };
7847
7848 struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7849 {
7850   typedef EmbeddingLookupSparseOptionsT NativeTableType;
7851   typedef EmbeddingLookupSparseOptionsBuilder Builder;
7852   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7853   {
7854     VT_COMBINER = 4
7855   };
7856   circle::CombinerType combiner() const
7857   {
7858     return static_cast<circle::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
7859   }
7860   bool Verify(flatbuffers::Verifier &verifier) const
7861   {
7862     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_COMBINER) &&
7863            verifier.EndTable();
7864   }
7865   EmbeddingLookupSparseOptionsT *
7866   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7867   void UnPackTo(EmbeddingLookupSparseOptionsT *_o,
7868                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7869   static flatbuffers::Offset<EmbeddingLookupSparseOptions>
7870   Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o,
7871        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7872 };
7873
7874 struct EmbeddingLookupSparseOptionsBuilder
7875 {
7876   typedef EmbeddingLookupSparseOptions Table;
7877   flatbuffers::FlatBufferBuilder &fbb_;
7878   flatbuffers::uoffset_t start_;
7879   void add_combiner(circle::CombinerType combiner)
7880   {
7881     fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER,
7882                             static_cast<int8_t>(combiner), 0);
7883   }
7884   explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7885   {
7886     start_ = fbb_.StartTable();
7887   }
7888   flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish()
7889   {
7890     const auto end = fbb_.EndTable(start_);
7891     auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
7892     return o;
7893   }
7894 };
7895
7896 inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
7897 CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
7898                                    circle::CombinerType combiner = circle::CombinerType_SUM)
7899 {
7900   EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
7901   builder_.add_combiner(combiner);
7902   return builder_.Finish();
7903 }
7904
7905 flatbuffers::Offset<EmbeddingLookupSparseOptions>
7906 CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
7907                                    const EmbeddingLookupSparseOptionsT *_o,
7908                                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7909
7910 struct GatherOptionsT : public flatbuffers::NativeTable
7911 {
7912   typedef GatherOptions TableType;
7913   int32_t axis = 0;
7914   int32_t batch_dims = 0;
7915 };
7916
7917 struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7918 {
7919   typedef GatherOptionsT NativeTableType;
7920   typedef GatherOptionsBuilder Builder;
7921   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
7922   {
7923     VT_AXIS = 4,
7924     VT_BATCH_DIMS = 6
7925   };
7926   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
7927   int32_t batch_dims() const { return GetField<int32_t>(VT_BATCH_DIMS, 0); }
7928   bool Verify(flatbuffers::Verifier &verifier) const
7929   {
7930     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
7931            VerifyField<int32_t>(verifier, VT_BATCH_DIMS) && verifier.EndTable();
7932   }
7933   GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7934   void UnPackTo(GatherOptionsT *_o,
7935                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7936   static flatbuffers::Offset<GatherOptions>
7937   Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o,
7938        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7939 };
7940
7941 struct GatherOptionsBuilder
7942 {
7943   typedef GatherOptions Table;
7944   flatbuffers::FlatBufferBuilder &fbb_;
7945   flatbuffers::uoffset_t start_;
7946   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0); }
7947   void add_batch_dims(int32_t batch_dims)
7948   {
7949     fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
7950   }
7951   explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
7952   {
7953     start_ = fbb_.StartTable();
7954   }
7955   flatbuffers::Offset<GatherOptions> Finish()
7956   {
7957     const auto end = fbb_.EndTable(start_);
7958     auto o = flatbuffers::Offset<GatherOptions>(end);
7959     return o;
7960   }
7961 };
7962
7963 inline flatbuffers::Offset<GatherOptions>
7964 CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis = 0, int32_t batch_dims = 0)
7965 {
7966   GatherOptionsBuilder builder_(_fbb);
7967   builder_.add_batch_dims(batch_dims);
7968   builder_.add_axis(axis);
7969   return builder_.Finish();
7970 }
7971
7972 flatbuffers::Offset<GatherOptions>
7973 CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o,
7974                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7975
7976 struct TransposeOptionsT : public flatbuffers::NativeTable
7977 {
7978   typedef TransposeOptions TableType;
7979 };
7980
7981 struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
7982 {
7983   typedef TransposeOptionsT NativeTableType;
7984   typedef TransposeOptionsBuilder Builder;
7985   bool Verify(flatbuffers::Verifier &verifier) const
7986   {
7987     return VerifyTableStart(verifier) && verifier.EndTable();
7988   }
7989   TransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7990   void UnPackTo(TransposeOptionsT *_o,
7991                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7992   static flatbuffers::Offset<TransposeOptions>
7993   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o,
7994        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7995 };
7996
7997 struct TransposeOptionsBuilder
7998 {
7999   typedef TransposeOptions Table;
8000   flatbuffers::FlatBufferBuilder &fbb_;
8001   flatbuffers::uoffset_t start_;
8002   explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8003   {
8004     start_ = fbb_.StartTable();
8005   }
8006   flatbuffers::Offset<TransposeOptions> Finish()
8007   {
8008     const auto end = fbb_.EndTable(start_);
8009     auto o = flatbuffers::Offset<TransposeOptions>(end);
8010     return o;
8011   }
8012 };
8013
8014 inline flatbuffers::Offset<TransposeOptions>
8015 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb)
8016 {
8017   TransposeOptionsBuilder builder_(_fbb);
8018   return builder_.Finish();
8019 }
8020
8021 flatbuffers::Offset<TransposeOptions>
8022 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o,
8023                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8024
8025 struct ExpOptionsT : public flatbuffers::NativeTable
8026 {
8027   typedef ExpOptions TableType;
8028 };
8029
8030 struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8031 {
8032   typedef ExpOptionsT NativeTableType;
8033   typedef ExpOptionsBuilder Builder;
8034   bool Verify(flatbuffers::Verifier &verifier) const
8035   {
8036     return VerifyTableStart(verifier) && verifier.EndTable();
8037   }
8038   ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8039   void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8040   static flatbuffers::Offset<ExpOptions>
8041   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o,
8042        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8043 };
8044
8045 struct ExpOptionsBuilder
8046 {
8047   typedef ExpOptions Table;
8048   flatbuffers::FlatBufferBuilder &fbb_;
8049   flatbuffers::uoffset_t start_;
8050   explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8051   {
8052     start_ = fbb_.StartTable();
8053   }
8054   flatbuffers::Offset<ExpOptions> Finish()
8055   {
8056     const auto end = fbb_.EndTable(start_);
8057     auto o = flatbuffers::Offset<ExpOptions>(end);
8058     return o;
8059   }
8060 };
8061
8062 inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb)
8063 {
8064   ExpOptionsBuilder builder_(_fbb);
8065   return builder_.Finish();
8066 }
8067
8068 flatbuffers::Offset<ExpOptions>
8069 CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o,
8070                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8071
8072 struct CosOptionsT : public flatbuffers::NativeTable
8073 {
8074   typedef CosOptions TableType;
8075 };
8076
8077 struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8078 {
8079   typedef CosOptionsT NativeTableType;
8080   typedef CosOptionsBuilder Builder;
8081   bool Verify(flatbuffers::Verifier &verifier) const
8082   {
8083     return VerifyTableStart(verifier) && verifier.EndTable();
8084   }
8085   CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8086   void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8087   static flatbuffers::Offset<CosOptions>
8088   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o,
8089        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8090 };
8091
8092 struct CosOptionsBuilder
8093 {
8094   typedef CosOptions Table;
8095   flatbuffers::FlatBufferBuilder &fbb_;
8096   flatbuffers::uoffset_t start_;
8097   explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8098   {
8099     start_ = fbb_.StartTable();
8100   }
8101   flatbuffers::Offset<CosOptions> Finish()
8102   {
8103     const auto end = fbb_.EndTable(start_);
8104     auto o = flatbuffers::Offset<CosOptions>(end);
8105     return o;
8106   }
8107 };
8108
8109 inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb)
8110 {
8111   CosOptionsBuilder builder_(_fbb);
8112   return builder_.Finish();
8113 }
8114
8115 flatbuffers::Offset<CosOptions>
8116 CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o,
8117                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8118
8119 struct ReducerOptionsT : public flatbuffers::NativeTable
8120 {
8121   typedef ReducerOptions TableType;
8122   bool keep_dims = false;
8123 };
8124
8125 struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8126 {
8127   typedef ReducerOptionsT NativeTableType;
8128   typedef ReducerOptionsBuilder Builder;
8129   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8130   {
8131     VT_KEEP_DIMS = 4
8132   };
8133   bool keep_dims() const { return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; }
8134   bool Verify(flatbuffers::Verifier &verifier) const
8135   {
8136     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) &&
8137            verifier.EndTable();
8138   }
8139   ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8140   void UnPackTo(ReducerOptionsT *_o,
8141                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8142   static flatbuffers::Offset<ReducerOptions>
8143   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o,
8144        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8145 };
8146
8147 struct ReducerOptionsBuilder
8148 {
8149   typedef ReducerOptions Table;
8150   flatbuffers::FlatBufferBuilder &fbb_;
8151   flatbuffers::uoffset_t start_;
8152   void add_keep_dims(bool keep_dims)
8153   {
8154     fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
8155   }
8156   explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8157   {
8158     start_ = fbb_.StartTable();
8159   }
8160   flatbuffers::Offset<ReducerOptions> Finish()
8161   {
8162     const auto end = fbb_.EndTable(start_);
8163     auto o = flatbuffers::Offset<ReducerOptions>(end);
8164     return o;
8165   }
8166 };
8167
8168 inline flatbuffers::Offset<ReducerOptions>
8169 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims = false)
8170 {
8171   ReducerOptionsBuilder builder_(_fbb);
8172   builder_.add_keep_dims(keep_dims);
8173   return builder_.Finish();
8174 }
8175
8176 flatbuffers::Offset<ReducerOptions>
8177 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o,
8178                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8179
8180 struct SqueezeOptionsT : public flatbuffers::NativeTable
8181 {
8182   typedef SqueezeOptions TableType;
8183   std::vector<int32_t> squeeze_dims{};
8184 };
8185
8186 struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8187 {
8188   typedef SqueezeOptionsT NativeTableType;
8189   typedef SqueezeOptionsBuilder Builder;
8190   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8191   {
8192     VT_SQUEEZE_DIMS = 4
8193   };
8194   const flatbuffers::Vector<int32_t> *squeeze_dims() const
8195   {
8196     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
8197   }
8198   bool Verify(flatbuffers::Verifier &verifier) const
8199   {
8200     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
8201            verifier.VerifyVector(squeeze_dims()) && verifier.EndTable();
8202   }
8203   SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8204   void UnPackTo(SqueezeOptionsT *_o,
8205                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8206   static flatbuffers::Offset<SqueezeOptions>
8207   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o,
8208        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8209 };
8210
8211 struct SqueezeOptionsBuilder
8212 {
8213   typedef SqueezeOptions Table;
8214   flatbuffers::FlatBufferBuilder &fbb_;
8215   flatbuffers::uoffset_t start_;
8216   void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims)
8217   {
8218     fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
8219   }
8220   explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8221   {
8222     start_ = fbb_.StartTable();
8223   }
8224   flatbuffers::Offset<SqueezeOptions> Finish()
8225   {
8226     const auto end = fbb_.EndTable(start_);
8227     auto o = flatbuffers::Offset<SqueezeOptions>(end);
8228     return o;
8229   }
8230 };
8231
8232 inline flatbuffers::Offset<SqueezeOptions>
8233 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb,
8234                      flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0)
8235 {
8236   SqueezeOptionsBuilder builder_(_fbb);
8237   builder_.add_squeeze_dims(squeeze_dims);
8238   return builder_.Finish();
8239 }
8240
8241 inline flatbuffers::Offset<SqueezeOptions>
8242 CreateSqueezeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb,
8243                            const std::vector<int32_t> *squeeze_dims = nullptr)
8244 {
8245   auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
8246   return circle::CreateSqueezeOptions(_fbb, squeeze_dims__);
8247 }
8248
8249 flatbuffers::Offset<SqueezeOptions>
8250 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o,
8251                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8252
8253 struct SplitOptionsT : public flatbuffers::NativeTable
8254 {
8255   typedef SplitOptions TableType;
8256   int32_t num_splits = 0;
8257 };
8258
8259 struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8260 {
8261   typedef SplitOptionsT NativeTableType;
8262   typedef SplitOptionsBuilder Builder;
8263   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8264   {
8265     VT_NUM_SPLITS = 4
8266   };
8267   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
8268   bool Verify(flatbuffers::Verifier &verifier) const
8269   {
8270     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
8271            verifier.EndTable();
8272   }
8273   SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8274   void UnPackTo(SplitOptionsT *_o,
8275                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8276   static flatbuffers::Offset<SplitOptions>
8277   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o,
8278        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8279 };
8280
8281 struct SplitOptionsBuilder
8282 {
8283   typedef SplitOptions Table;
8284   flatbuffers::FlatBufferBuilder &fbb_;
8285   flatbuffers::uoffset_t start_;
8286   void add_num_splits(int32_t num_splits)
8287   {
8288     fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
8289   }
8290   explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8291   {
8292     start_ = fbb_.StartTable();
8293   }
8294   flatbuffers::Offset<SplitOptions> Finish()
8295   {
8296     const auto end = fbb_.EndTable(start_);
8297     auto o = flatbuffers::Offset<SplitOptions>(end);
8298     return o;
8299   }
8300 };
8301
8302 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb,
8303                                                             int32_t num_splits = 0)
8304 {
8305   SplitOptionsBuilder builder_(_fbb);
8306   builder_.add_num_splits(num_splits);
8307   return builder_.Finish();
8308 }
8309
8310 flatbuffers::Offset<SplitOptions>
8311 CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o,
8312                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8313
8314 struct SplitVOptionsT : public flatbuffers::NativeTable
8315 {
8316   typedef SplitVOptions TableType;
8317   int32_t num_splits = 0;
8318 };
8319
8320 struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8321 {
8322   typedef SplitVOptionsT NativeTableType;
8323   typedef SplitVOptionsBuilder Builder;
8324   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8325   {
8326     VT_NUM_SPLITS = 4
8327   };
8328   int32_t num_splits() const { return GetField<int32_t>(VT_NUM_SPLITS, 0); }
8329   bool Verify(flatbuffers::Verifier &verifier) const
8330   {
8331     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM_SPLITS) &&
8332            verifier.EndTable();
8333   }
8334   SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8335   void UnPackTo(SplitVOptionsT *_o,
8336                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8337   static flatbuffers::Offset<SplitVOptions>
8338   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o,
8339        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8340 };
8341
8342 struct SplitVOptionsBuilder
8343 {
8344   typedef SplitVOptions Table;
8345   flatbuffers::FlatBufferBuilder &fbb_;
8346   flatbuffers::uoffset_t start_;
8347   void add_num_splits(int32_t num_splits)
8348   {
8349     fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
8350   }
8351   explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8352   {
8353     start_ = fbb_.StartTable();
8354   }
8355   flatbuffers::Offset<SplitVOptions> Finish()
8356   {
8357     const auto end = fbb_.EndTable(start_);
8358     auto o = flatbuffers::Offset<SplitVOptions>(end);
8359     return o;
8360   }
8361 };
8362
8363 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb,
8364                                                               int32_t num_splits = 0)
8365 {
8366   SplitVOptionsBuilder builder_(_fbb);
8367   builder_.add_num_splits(num_splits);
8368   return builder_.Finish();
8369 }
8370
8371 flatbuffers::Offset<SplitVOptions>
8372 CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o,
8373                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8374
8375 struct StridedSliceOptionsT : public flatbuffers::NativeTable
8376 {
8377   typedef StridedSliceOptions TableType;
8378   int32_t begin_mask = 0;
8379   int32_t end_mask = 0;
8380   int32_t ellipsis_mask = 0;
8381   int32_t new_axis_mask = 0;
8382   int32_t shrink_axis_mask = 0;
8383 };
8384
8385 struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8386 {
8387   typedef StridedSliceOptionsT NativeTableType;
8388   typedef StridedSliceOptionsBuilder Builder;
8389   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8390   {
8391     VT_BEGIN_MASK = 4,
8392     VT_END_MASK = 6,
8393     VT_ELLIPSIS_MASK = 8,
8394     VT_NEW_AXIS_MASK = 10,
8395     VT_SHRINK_AXIS_MASK = 12
8396   };
8397   int32_t begin_mask() const { return GetField<int32_t>(VT_BEGIN_MASK, 0); }
8398   int32_t end_mask() const { return GetField<int32_t>(VT_END_MASK, 0); }
8399   int32_t ellipsis_mask() const { return GetField<int32_t>(VT_ELLIPSIS_MASK, 0); }
8400   int32_t new_axis_mask() const { return GetField<int32_t>(VT_NEW_AXIS_MASK, 0); }
8401   int32_t shrink_axis_mask() const { return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0); }
8402   bool Verify(flatbuffers::Verifier &verifier) const
8403   {
8404     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_BEGIN_MASK) &&
8405            VerifyField<int32_t>(verifier, VT_END_MASK) &&
8406            VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) &&
8407            VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) &&
8408            VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) && verifier.EndTable();
8409   }
8410   StridedSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8411   void UnPackTo(StridedSliceOptionsT *_o,
8412                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8413   static flatbuffers::Offset<StridedSliceOptions>
8414   Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o,
8415        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8416 };
8417
8418 struct StridedSliceOptionsBuilder
8419 {
8420   typedef StridedSliceOptions Table;
8421   flatbuffers::FlatBufferBuilder &fbb_;
8422   flatbuffers::uoffset_t start_;
8423   void add_begin_mask(int32_t begin_mask)
8424   {
8425     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
8426   }
8427   void add_end_mask(int32_t end_mask)
8428   {
8429     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
8430   }
8431   void add_ellipsis_mask(int32_t ellipsis_mask)
8432   {
8433     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
8434   }
8435   void add_new_axis_mask(int32_t new_axis_mask)
8436   {
8437     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
8438   }
8439   void add_shrink_axis_mask(int32_t shrink_axis_mask)
8440   {
8441     fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
8442   }
8443   explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8444   {
8445     start_ = fbb_.StartTable();
8446   }
8447   flatbuffers::Offset<StridedSliceOptions> Finish()
8448   {
8449     const auto end = fbb_.EndTable(start_);
8450     auto o = flatbuffers::Offset<StridedSliceOptions>(end);
8451     return o;
8452   }
8453 };
8454
8455 inline flatbuffers::Offset<StridedSliceOptions>
8456 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask = 0,
8457                           int32_t end_mask = 0, int32_t ellipsis_mask = 0,
8458                           int32_t new_axis_mask = 0, int32_t shrink_axis_mask = 0)
8459 {
8460   StridedSliceOptionsBuilder builder_(_fbb);
8461   builder_.add_shrink_axis_mask(shrink_axis_mask);
8462   builder_.add_new_axis_mask(new_axis_mask);
8463   builder_.add_ellipsis_mask(ellipsis_mask);
8464   builder_.add_end_mask(end_mask);
8465   builder_.add_begin_mask(begin_mask);
8466   return builder_.Finish();
8467 }
8468
8469 flatbuffers::Offset<StridedSliceOptions>
8470 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o,
8471                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8472
8473 struct LogSoftmaxOptionsT : public flatbuffers::NativeTable
8474 {
8475   typedef LogSoftmaxOptions TableType;
8476 };
8477
8478 struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8479 {
8480   typedef LogSoftmaxOptionsT NativeTableType;
8481   typedef LogSoftmaxOptionsBuilder Builder;
8482   bool Verify(flatbuffers::Verifier &verifier) const
8483   {
8484     return VerifyTableStart(verifier) && verifier.EndTable();
8485   }
8486   LogSoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8487   void UnPackTo(LogSoftmaxOptionsT *_o,
8488                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8489   static flatbuffers::Offset<LogSoftmaxOptions>
8490   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o,
8491        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8492 };
8493
8494 struct LogSoftmaxOptionsBuilder
8495 {
8496   typedef LogSoftmaxOptions Table;
8497   flatbuffers::FlatBufferBuilder &fbb_;
8498   flatbuffers::uoffset_t start_;
8499   explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8500   {
8501     start_ = fbb_.StartTable();
8502   }
8503   flatbuffers::Offset<LogSoftmaxOptions> Finish()
8504   {
8505     const auto end = fbb_.EndTable(start_);
8506     auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
8507     return o;
8508   }
8509 };
8510
8511 inline flatbuffers::Offset<LogSoftmaxOptions>
8512 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
8513 {
8514   LogSoftmaxOptionsBuilder builder_(_fbb);
8515   return builder_.Finish();
8516 }
8517
8518 flatbuffers::Offset<LogSoftmaxOptions>
8519 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o,
8520                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8521
8522 struct CastOptionsT : public flatbuffers::NativeTable
8523 {
8524   typedef CastOptions TableType;
8525   circle::TensorType in_data_type = circle::TensorType_FLOAT32;
8526   circle::TensorType out_data_type = circle::TensorType_FLOAT32;
8527 };
8528
8529 struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8530 {
8531   typedef CastOptionsT NativeTableType;
8532   typedef CastOptionsBuilder Builder;
8533   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8534   {
8535     VT_IN_DATA_TYPE = 4,
8536     VT_OUT_DATA_TYPE = 6
8537   };
8538   circle::TensorType in_data_type() const
8539   {
8540     return static_cast<circle::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
8541   }
8542   circle::TensorType out_data_type() const
8543   {
8544     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
8545   }
8546   bool Verify(flatbuffers::Verifier &verifier) const
8547   {
8548     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) &&
8549            VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) && verifier.EndTable();
8550   }
8551   CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8552   void UnPackTo(CastOptionsT *_o,
8553                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8554   static flatbuffers::Offset<CastOptions>
8555   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o,
8556        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8557 };
8558
8559 struct CastOptionsBuilder
8560 {
8561   typedef CastOptions Table;
8562   flatbuffers::FlatBufferBuilder &fbb_;
8563   flatbuffers::uoffset_t start_;
8564   void add_in_data_type(circle::TensorType in_data_type)
8565   {
8566     fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
8567   }
8568   void add_out_data_type(circle::TensorType out_data_type)
8569   {
8570     fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
8571   }
8572   explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8573   {
8574     start_ = fbb_.StartTable();
8575   }
8576   flatbuffers::Offset<CastOptions> Finish()
8577   {
8578     const auto end = fbb_.EndTable(start_);
8579     auto o = flatbuffers::Offset<CastOptions>(end);
8580     return o;
8581   }
8582 };
8583
8584 inline flatbuffers::Offset<CastOptions>
8585 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb,
8586                   circle::TensorType in_data_type = circle::TensorType_FLOAT32,
8587                   circle::TensorType out_data_type = circle::TensorType_FLOAT32)
8588 {
8589   CastOptionsBuilder builder_(_fbb);
8590   builder_.add_out_data_type(out_data_type);
8591   builder_.add_in_data_type(in_data_type);
8592   return builder_.Finish();
8593 }
8594
8595 flatbuffers::Offset<CastOptions>
8596 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o,
8597                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8598
8599 struct DequantizeOptionsT : public flatbuffers::NativeTable
8600 {
8601   typedef DequantizeOptions TableType;
8602 };
8603
8604 struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8605 {
8606   typedef DequantizeOptionsT NativeTableType;
8607   typedef DequantizeOptionsBuilder Builder;
8608   bool Verify(flatbuffers::Verifier &verifier) const
8609   {
8610     return VerifyTableStart(verifier) && verifier.EndTable();
8611   }
8612   DequantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8613   void UnPackTo(DequantizeOptionsT *_o,
8614                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8615   static flatbuffers::Offset<DequantizeOptions>
8616   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o,
8617        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8618 };
8619
8620 struct DequantizeOptionsBuilder
8621 {
8622   typedef DequantizeOptions Table;
8623   flatbuffers::FlatBufferBuilder &fbb_;
8624   flatbuffers::uoffset_t start_;
8625   explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8626   {
8627     start_ = fbb_.StartTable();
8628   }
8629   flatbuffers::Offset<DequantizeOptions> Finish()
8630   {
8631     const auto end = fbb_.EndTable(start_);
8632     auto o = flatbuffers::Offset<DequantizeOptions>(end);
8633     return o;
8634   }
8635 };
8636
8637 inline flatbuffers::Offset<DequantizeOptions>
8638 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
8639 {
8640   DequantizeOptionsBuilder builder_(_fbb);
8641   return builder_.Finish();
8642 }
8643
8644 flatbuffers::Offset<DequantizeOptions>
8645 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o,
8646                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8647
8648 struct MaximumMinimumOptionsT : public flatbuffers::NativeTable
8649 {
8650   typedef MaximumMinimumOptions TableType;
8651 };
8652
8653 struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8654 {
8655   typedef MaximumMinimumOptionsT NativeTableType;
8656   typedef MaximumMinimumOptionsBuilder Builder;
8657   bool Verify(flatbuffers::Verifier &verifier) const
8658   {
8659     return VerifyTableStart(verifier) && verifier.EndTable();
8660   }
8661   MaximumMinimumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8662   void UnPackTo(MaximumMinimumOptionsT *_o,
8663                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8664   static flatbuffers::Offset<MaximumMinimumOptions>
8665   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o,
8666        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8667 };
8668
8669 struct MaximumMinimumOptionsBuilder
8670 {
8671   typedef MaximumMinimumOptions Table;
8672   flatbuffers::FlatBufferBuilder &fbb_;
8673   flatbuffers::uoffset_t start_;
8674   explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8675   {
8676     start_ = fbb_.StartTable();
8677   }
8678   flatbuffers::Offset<MaximumMinimumOptions> Finish()
8679   {
8680     const auto end = fbb_.EndTable(start_);
8681     auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
8682     return o;
8683   }
8684 };
8685
8686 inline flatbuffers::Offset<MaximumMinimumOptions>
8687 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb)
8688 {
8689   MaximumMinimumOptionsBuilder builder_(_fbb);
8690   return builder_.Finish();
8691 }
8692
8693 flatbuffers::Offset<MaximumMinimumOptions>
8694 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o,
8695                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8696
8697 struct TileOptionsT : public flatbuffers::NativeTable
8698 {
8699   typedef TileOptions TableType;
8700 };
8701
8702 struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8703 {
8704   typedef TileOptionsT NativeTableType;
8705   typedef TileOptionsBuilder Builder;
8706   bool Verify(flatbuffers::Verifier &verifier) const
8707   {
8708     return VerifyTableStart(verifier) && verifier.EndTable();
8709   }
8710   TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8711   void UnPackTo(TileOptionsT *_o,
8712                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8713   static flatbuffers::Offset<TileOptions>
8714   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o,
8715        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8716 };
8717
8718 struct TileOptionsBuilder
8719 {
8720   typedef TileOptions Table;
8721   flatbuffers::FlatBufferBuilder &fbb_;
8722   flatbuffers::uoffset_t start_;
8723   explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8724   {
8725     start_ = fbb_.StartTable();
8726   }
8727   flatbuffers::Offset<TileOptions> Finish()
8728   {
8729     const auto end = fbb_.EndTable(start_);
8730     auto o = flatbuffers::Offset<TileOptions>(end);
8731     return o;
8732   }
8733 };
8734
8735 inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb)
8736 {
8737   TileOptionsBuilder builder_(_fbb);
8738   return builder_.Finish();
8739 }
8740
8741 flatbuffers::Offset<TileOptions>
8742 CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o,
8743                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8744
8745 struct ArgMaxOptionsT : public flatbuffers::NativeTable
8746 {
8747   typedef ArgMaxOptions TableType;
8748   circle::TensorType output_type = circle::TensorType_FLOAT32;
8749 };
8750
8751 struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8752 {
8753   typedef ArgMaxOptionsT NativeTableType;
8754   typedef ArgMaxOptionsBuilder Builder;
8755   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8756   {
8757     VT_OUTPUT_TYPE = 4
8758   };
8759   circle::TensorType output_type() const
8760   {
8761     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
8762   }
8763   bool Verify(flatbuffers::Verifier &verifier) const
8764   {
8765     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
8766            verifier.EndTable();
8767   }
8768   ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8769   void UnPackTo(ArgMaxOptionsT *_o,
8770                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8771   static flatbuffers::Offset<ArgMaxOptions>
8772   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o,
8773        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8774 };
8775
8776 struct ArgMaxOptionsBuilder
8777 {
8778   typedef ArgMaxOptions Table;
8779   flatbuffers::FlatBufferBuilder &fbb_;
8780   flatbuffers::uoffset_t start_;
8781   void add_output_type(circle::TensorType output_type)
8782   {
8783     fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
8784   }
8785   explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8786   {
8787     start_ = fbb_.StartTable();
8788   }
8789   flatbuffers::Offset<ArgMaxOptions> Finish()
8790   {
8791     const auto end = fbb_.EndTable(start_);
8792     auto o = flatbuffers::Offset<ArgMaxOptions>(end);
8793     return o;
8794   }
8795 };
8796
8797 inline flatbuffers::Offset<ArgMaxOptions>
8798 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb,
8799                     circle::TensorType output_type = circle::TensorType_FLOAT32)
8800 {
8801   ArgMaxOptionsBuilder builder_(_fbb);
8802   builder_.add_output_type(output_type);
8803   return builder_.Finish();
8804 }
8805
8806 flatbuffers::Offset<ArgMaxOptions>
8807 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o,
8808                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8809
8810 struct ArgMinOptionsT : public flatbuffers::NativeTable
8811 {
8812   typedef ArgMinOptions TableType;
8813   circle::TensorType output_type = circle::TensorType_FLOAT32;
8814 };
8815
8816 struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8817 {
8818   typedef ArgMinOptionsT NativeTableType;
8819   typedef ArgMinOptionsBuilder Builder;
8820   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
8821   {
8822     VT_OUTPUT_TYPE = 4
8823   };
8824   circle::TensorType output_type() const
8825   {
8826     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
8827   }
8828   bool Verify(flatbuffers::Verifier &verifier) const
8829   {
8830     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) &&
8831            verifier.EndTable();
8832   }
8833   ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8834   void UnPackTo(ArgMinOptionsT *_o,
8835                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8836   static flatbuffers::Offset<ArgMinOptions>
8837   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o,
8838        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8839 };
8840
8841 struct ArgMinOptionsBuilder
8842 {
8843   typedef ArgMinOptions Table;
8844   flatbuffers::FlatBufferBuilder &fbb_;
8845   flatbuffers::uoffset_t start_;
8846   void add_output_type(circle::TensorType output_type)
8847   {
8848     fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
8849   }
8850   explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8851   {
8852     start_ = fbb_.StartTable();
8853   }
8854   flatbuffers::Offset<ArgMinOptions> Finish()
8855   {
8856     const auto end = fbb_.EndTable(start_);
8857     auto o = flatbuffers::Offset<ArgMinOptions>(end);
8858     return o;
8859   }
8860 };
8861
8862 inline flatbuffers::Offset<ArgMinOptions>
8863 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb,
8864                     circle::TensorType output_type = circle::TensorType_FLOAT32)
8865 {
8866   ArgMinOptionsBuilder builder_(_fbb);
8867   builder_.add_output_type(output_type);
8868   return builder_.Finish();
8869 }
8870
8871 flatbuffers::Offset<ArgMinOptions>
8872 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o,
8873                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8874
8875 struct GreaterOptionsT : public flatbuffers::NativeTable
8876 {
8877   typedef GreaterOptions TableType;
8878 };
8879
8880 struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8881 {
8882   typedef GreaterOptionsT NativeTableType;
8883   typedef GreaterOptionsBuilder Builder;
8884   bool Verify(flatbuffers::Verifier &verifier) const
8885   {
8886     return VerifyTableStart(verifier) && verifier.EndTable();
8887   }
8888   GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8889   void UnPackTo(GreaterOptionsT *_o,
8890                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8891   static flatbuffers::Offset<GreaterOptions>
8892   Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o,
8893        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8894 };
8895
8896 struct GreaterOptionsBuilder
8897 {
8898   typedef GreaterOptions Table;
8899   flatbuffers::FlatBufferBuilder &fbb_;
8900   flatbuffers::uoffset_t start_;
8901   explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8902   {
8903     start_ = fbb_.StartTable();
8904   }
8905   flatbuffers::Offset<GreaterOptions> Finish()
8906   {
8907     const auto end = fbb_.EndTable(start_);
8908     auto o = flatbuffers::Offset<GreaterOptions>(end);
8909     return o;
8910   }
8911 };
8912
8913 inline flatbuffers::Offset<GreaterOptions>
8914 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb)
8915 {
8916   GreaterOptionsBuilder builder_(_fbb);
8917   return builder_.Finish();
8918 }
8919
8920 flatbuffers::Offset<GreaterOptions>
8921 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o,
8922                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8923
8924 struct GreaterEqualOptionsT : public flatbuffers::NativeTable
8925 {
8926   typedef GreaterEqualOptions TableType;
8927 };
8928
8929 struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8930 {
8931   typedef GreaterEqualOptionsT NativeTableType;
8932   typedef GreaterEqualOptionsBuilder Builder;
8933   bool Verify(flatbuffers::Verifier &verifier) const
8934   {
8935     return VerifyTableStart(verifier) && verifier.EndTable();
8936   }
8937   GreaterEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8938   void UnPackTo(GreaterEqualOptionsT *_o,
8939                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8940   static flatbuffers::Offset<GreaterEqualOptions>
8941   Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o,
8942        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8943 };
8944
8945 struct GreaterEqualOptionsBuilder
8946 {
8947   typedef GreaterEqualOptions Table;
8948   flatbuffers::FlatBufferBuilder &fbb_;
8949   flatbuffers::uoffset_t start_;
8950   explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
8951   {
8952     start_ = fbb_.StartTable();
8953   }
8954   flatbuffers::Offset<GreaterEqualOptions> Finish()
8955   {
8956     const auto end = fbb_.EndTable(start_);
8957     auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
8958     return o;
8959   }
8960 };
8961
8962 inline flatbuffers::Offset<GreaterEqualOptions>
8963 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
8964 {
8965   GreaterEqualOptionsBuilder builder_(_fbb);
8966   return builder_.Finish();
8967 }
8968
8969 flatbuffers::Offset<GreaterEqualOptions>
8970 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o,
8971                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8972
8973 struct LessOptionsT : public flatbuffers::NativeTable
8974 {
8975   typedef LessOptions TableType;
8976 };
8977
8978 struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
8979 {
8980   typedef LessOptionsT NativeTableType;
8981   typedef LessOptionsBuilder Builder;
8982   bool Verify(flatbuffers::Verifier &verifier) const
8983   {
8984     return VerifyTableStart(verifier) && verifier.EndTable();
8985   }
8986   LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8987   void UnPackTo(LessOptionsT *_o,
8988                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8989   static flatbuffers::Offset<LessOptions>
8990   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o,
8991        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8992 };
8993
8994 struct LessOptionsBuilder
8995 {
8996   typedef LessOptions Table;
8997   flatbuffers::FlatBufferBuilder &fbb_;
8998   flatbuffers::uoffset_t start_;
8999   explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9000   {
9001     start_ = fbb_.StartTable();
9002   }
9003   flatbuffers::Offset<LessOptions> Finish()
9004   {
9005     const auto end = fbb_.EndTable(start_);
9006     auto o = flatbuffers::Offset<LessOptions>(end);
9007     return o;
9008   }
9009 };
9010
9011 inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb)
9012 {
9013   LessOptionsBuilder builder_(_fbb);
9014   return builder_.Finish();
9015 }
9016
9017 flatbuffers::Offset<LessOptions>
9018 CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o,
9019                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9020
9021 struct LessEqualOptionsT : public flatbuffers::NativeTable
9022 {
9023   typedef LessEqualOptions TableType;
9024 };
9025
9026 struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9027 {
9028   typedef LessEqualOptionsT NativeTableType;
9029   typedef LessEqualOptionsBuilder Builder;
9030   bool Verify(flatbuffers::Verifier &verifier) const
9031   {
9032     return VerifyTableStart(verifier) && verifier.EndTable();
9033   }
9034   LessEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9035   void UnPackTo(LessEqualOptionsT *_o,
9036                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9037   static flatbuffers::Offset<LessEqualOptions>
9038   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o,
9039        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9040 };
9041
9042 struct LessEqualOptionsBuilder
9043 {
9044   typedef LessEqualOptions Table;
9045   flatbuffers::FlatBufferBuilder &fbb_;
9046   flatbuffers::uoffset_t start_;
9047   explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9048   {
9049     start_ = fbb_.StartTable();
9050   }
9051   flatbuffers::Offset<LessEqualOptions> Finish()
9052   {
9053     const auto end = fbb_.EndTable(start_);
9054     auto o = flatbuffers::Offset<LessEqualOptions>(end);
9055     return o;
9056   }
9057 };
9058
9059 inline flatbuffers::Offset<LessEqualOptions>
9060 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
9061 {
9062   LessEqualOptionsBuilder builder_(_fbb);
9063   return builder_.Finish();
9064 }
9065
9066 flatbuffers::Offset<LessEqualOptions>
9067 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o,
9068                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9069
9070 struct NegOptionsT : public flatbuffers::NativeTable
9071 {
9072   typedef NegOptions TableType;
9073 };
9074
9075 struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9076 {
9077   typedef NegOptionsT NativeTableType;
9078   typedef NegOptionsBuilder Builder;
9079   bool Verify(flatbuffers::Verifier &verifier) const
9080   {
9081     return VerifyTableStart(verifier) && verifier.EndTable();
9082   }
9083   NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9084   void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9085   static flatbuffers::Offset<NegOptions>
9086   Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o,
9087        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9088 };
9089
9090 struct NegOptionsBuilder
9091 {
9092   typedef NegOptions Table;
9093   flatbuffers::FlatBufferBuilder &fbb_;
9094   flatbuffers::uoffset_t start_;
9095   explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9096   {
9097     start_ = fbb_.StartTable();
9098   }
9099   flatbuffers::Offset<NegOptions> Finish()
9100   {
9101     const auto end = fbb_.EndTable(start_);
9102     auto o = flatbuffers::Offset<NegOptions>(end);
9103     return o;
9104   }
9105 };
9106
9107 inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb)
9108 {
9109   NegOptionsBuilder builder_(_fbb);
9110   return builder_.Finish();
9111 }
9112
9113 flatbuffers::Offset<NegOptions>
9114 CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o,
9115                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9116
9117 struct SelectOptionsT : public flatbuffers::NativeTable
9118 {
9119   typedef SelectOptions TableType;
9120 };
9121
9122 struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9123 {
9124   typedef SelectOptionsT NativeTableType;
9125   typedef SelectOptionsBuilder Builder;
9126   bool Verify(flatbuffers::Verifier &verifier) const
9127   {
9128     return VerifyTableStart(verifier) && verifier.EndTable();
9129   }
9130   SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9131   void UnPackTo(SelectOptionsT *_o,
9132                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9133   static flatbuffers::Offset<SelectOptions>
9134   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o,
9135        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9136 };
9137
9138 struct SelectOptionsBuilder
9139 {
9140   typedef SelectOptions Table;
9141   flatbuffers::FlatBufferBuilder &fbb_;
9142   flatbuffers::uoffset_t start_;
9143   explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9144   {
9145     start_ = fbb_.StartTable();
9146   }
9147   flatbuffers::Offset<SelectOptions> Finish()
9148   {
9149     const auto end = fbb_.EndTable(start_);
9150     auto o = flatbuffers::Offset<SelectOptions>(end);
9151     return o;
9152   }
9153 };
9154
9155 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb)
9156 {
9157   SelectOptionsBuilder builder_(_fbb);
9158   return builder_.Finish();
9159 }
9160
9161 flatbuffers::Offset<SelectOptions>
9162 CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o,
9163                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9164
9165 struct SliceOptionsT : public flatbuffers::NativeTable
9166 {
9167   typedef SliceOptions TableType;
9168 };
9169
9170 struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9171 {
9172   typedef SliceOptionsT NativeTableType;
9173   typedef SliceOptionsBuilder Builder;
9174   bool Verify(flatbuffers::Verifier &verifier) const
9175   {
9176     return VerifyTableStart(verifier) && verifier.EndTable();
9177   }
9178   SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9179   void UnPackTo(SliceOptionsT *_o,
9180                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9181   static flatbuffers::Offset<SliceOptions>
9182   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o,
9183        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9184 };
9185
9186 struct SliceOptionsBuilder
9187 {
9188   typedef SliceOptions Table;
9189   flatbuffers::FlatBufferBuilder &fbb_;
9190   flatbuffers::uoffset_t start_;
9191   explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9192   {
9193     start_ = fbb_.StartTable();
9194   }
9195   flatbuffers::Offset<SliceOptions> Finish()
9196   {
9197     const auto end = fbb_.EndTable(start_);
9198     auto o = flatbuffers::Offset<SliceOptions>(end);
9199     return o;
9200   }
9201 };
9202
9203 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
9204 {
9205   SliceOptionsBuilder builder_(_fbb);
9206   return builder_.Finish();
9207 }
9208
9209 flatbuffers::Offset<SliceOptions>
9210 CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o,
9211                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9212
9213 struct TransposeConvOptionsT : public flatbuffers::NativeTable
9214 {
9215   typedef TransposeConvOptions TableType;
9216   circle::Padding padding = circle::Padding_SAME;
9217   int32_t stride_w = 0;
9218   int32_t stride_h = 0;
9219 };
9220
9221 struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9222 {
9223   typedef TransposeConvOptionsT NativeTableType;
9224   typedef TransposeConvOptionsBuilder Builder;
9225   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9226   {
9227     VT_PADDING = 4,
9228     VT_STRIDE_W = 6,
9229     VT_STRIDE_H = 8
9230   };
9231   circle::Padding padding() const
9232   {
9233     return static_cast<circle::Padding>(GetField<int8_t>(VT_PADDING, 0));
9234   }
9235   int32_t stride_w() const { return GetField<int32_t>(VT_STRIDE_W, 0); }
9236   int32_t stride_h() const { return GetField<int32_t>(VT_STRIDE_H, 0); }
9237   bool Verify(flatbuffers::Verifier &verifier) const
9238   {
9239     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_PADDING) &&
9240            VerifyField<int32_t>(verifier, VT_STRIDE_W) &&
9241            VerifyField<int32_t>(verifier, VT_STRIDE_H) && verifier.EndTable();
9242   }
9243   TransposeConvOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9244   void UnPackTo(TransposeConvOptionsT *_o,
9245                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9246   static flatbuffers::Offset<TransposeConvOptions>
9247   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o,
9248        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9249 };
9250
9251 struct TransposeConvOptionsBuilder
9252 {
9253   typedef TransposeConvOptions Table;
9254   flatbuffers::FlatBufferBuilder &fbb_;
9255   flatbuffers::uoffset_t start_;
9256   void add_padding(circle::Padding padding)
9257   {
9258     fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
9259   }
9260   void add_stride_w(int32_t stride_w)
9261   {
9262     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
9263   }
9264   void add_stride_h(int32_t stride_h)
9265   {
9266     fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
9267   }
9268   explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9269   {
9270     start_ = fbb_.StartTable();
9271   }
9272   flatbuffers::Offset<TransposeConvOptions> Finish()
9273   {
9274     const auto end = fbb_.EndTable(start_);
9275     auto o = flatbuffers::Offset<TransposeConvOptions>(end);
9276     return o;
9277   }
9278 };
9279
9280 inline flatbuffers::Offset<TransposeConvOptions>
9281 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb,
9282                            circle::Padding padding = circle::Padding_SAME, int32_t stride_w = 0,
9283                            int32_t stride_h = 0)
9284 {
9285   TransposeConvOptionsBuilder builder_(_fbb);
9286   builder_.add_stride_h(stride_h);
9287   builder_.add_stride_w(stride_w);
9288   builder_.add_padding(padding);
9289   return builder_.Finish();
9290 }
9291
9292 flatbuffers::Offset<TransposeConvOptions>
9293 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o,
9294                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9295
9296 struct ExpandDimsOptionsT : public flatbuffers::NativeTable
9297 {
9298   typedef ExpandDimsOptions TableType;
9299 };
9300
9301 struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9302 {
9303   typedef ExpandDimsOptionsT NativeTableType;
9304   typedef ExpandDimsOptionsBuilder Builder;
9305   bool Verify(flatbuffers::Verifier &verifier) const
9306   {
9307     return VerifyTableStart(verifier) && verifier.EndTable();
9308   }
9309   ExpandDimsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9310   void UnPackTo(ExpandDimsOptionsT *_o,
9311                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9312   static flatbuffers::Offset<ExpandDimsOptions>
9313   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o,
9314        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9315 };
9316
9317 struct ExpandDimsOptionsBuilder
9318 {
9319   typedef ExpandDimsOptions Table;
9320   flatbuffers::FlatBufferBuilder &fbb_;
9321   flatbuffers::uoffset_t start_;
9322   explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9323   {
9324     start_ = fbb_.StartTable();
9325   }
9326   flatbuffers::Offset<ExpandDimsOptions> Finish()
9327   {
9328     const auto end = fbb_.EndTable(start_);
9329     auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
9330     return o;
9331   }
9332 };
9333
9334 inline flatbuffers::Offset<ExpandDimsOptions>
9335 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb)
9336 {
9337   ExpandDimsOptionsBuilder builder_(_fbb);
9338   return builder_.Finish();
9339 }
9340
9341 flatbuffers::Offset<ExpandDimsOptions>
9342 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o,
9343                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9344
9345 struct SparseToDenseOptionsT : public flatbuffers::NativeTable
9346 {
9347   typedef SparseToDenseOptions TableType;
9348   bool validate_indices = false;
9349 };
9350
9351 struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9352 {
9353   typedef SparseToDenseOptionsT NativeTableType;
9354   typedef SparseToDenseOptionsBuilder Builder;
9355   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9356   {
9357     VT_VALIDATE_INDICES = 4
9358   };
9359   bool validate_indices() const { return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0; }
9360   bool Verify(flatbuffers::Verifier &verifier) const
9361   {
9362     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) &&
9363            verifier.EndTable();
9364   }
9365   SparseToDenseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9366   void UnPackTo(SparseToDenseOptionsT *_o,
9367                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9368   static flatbuffers::Offset<SparseToDenseOptions>
9369   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o,
9370        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9371 };
9372
9373 struct SparseToDenseOptionsBuilder
9374 {
9375   typedef SparseToDenseOptions Table;
9376   flatbuffers::FlatBufferBuilder &fbb_;
9377   flatbuffers::uoffset_t start_;
9378   void add_validate_indices(bool validate_indices)
9379   {
9380     fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES,
9381                              static_cast<uint8_t>(validate_indices), 0);
9382   }
9383   explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9384   {
9385     start_ = fbb_.StartTable();
9386   }
9387   flatbuffers::Offset<SparseToDenseOptions> Finish()
9388   {
9389     const auto end = fbb_.EndTable(start_);
9390     auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
9391     return o;
9392   }
9393 };
9394
9395 inline flatbuffers::Offset<SparseToDenseOptions>
9396 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices = false)
9397 {
9398   SparseToDenseOptionsBuilder builder_(_fbb);
9399   builder_.add_validate_indices(validate_indices);
9400   return builder_.Finish();
9401 }
9402
9403 flatbuffers::Offset<SparseToDenseOptions>
9404 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o,
9405                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9406
9407 struct EqualOptionsT : public flatbuffers::NativeTable
9408 {
9409   typedef EqualOptions TableType;
9410 };
9411
9412 struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9413 {
9414   typedef EqualOptionsT NativeTableType;
9415   typedef EqualOptionsBuilder Builder;
9416   bool Verify(flatbuffers::Verifier &verifier) const
9417   {
9418     return VerifyTableStart(verifier) && verifier.EndTable();
9419   }
9420   EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9421   void UnPackTo(EqualOptionsT *_o,
9422                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9423   static flatbuffers::Offset<EqualOptions>
9424   Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o,
9425        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9426 };
9427
9428 struct EqualOptionsBuilder
9429 {
9430   typedef EqualOptions Table;
9431   flatbuffers::FlatBufferBuilder &fbb_;
9432   flatbuffers::uoffset_t start_;
9433   explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9434   {
9435     start_ = fbb_.StartTable();
9436   }
9437   flatbuffers::Offset<EqualOptions> Finish()
9438   {
9439     const auto end = fbb_.EndTable(start_);
9440     auto o = flatbuffers::Offset<EqualOptions>(end);
9441     return o;
9442   }
9443 };
9444
9445 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
9446 {
9447   EqualOptionsBuilder builder_(_fbb);
9448   return builder_.Finish();
9449 }
9450
9451 flatbuffers::Offset<EqualOptions>
9452 CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o,
9453                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9454
9455 struct NotEqualOptionsT : public flatbuffers::NativeTable
9456 {
9457   typedef NotEqualOptions TableType;
9458 };
9459
9460 struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9461 {
9462   typedef NotEqualOptionsT NativeTableType;
9463   typedef NotEqualOptionsBuilder Builder;
9464   bool Verify(flatbuffers::Verifier &verifier) const
9465   {
9466     return VerifyTableStart(verifier) && verifier.EndTable();
9467   }
9468   NotEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9469   void UnPackTo(NotEqualOptionsT *_o,
9470                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9471   static flatbuffers::Offset<NotEqualOptions>
9472   Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o,
9473        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9474 };
9475
9476 struct NotEqualOptionsBuilder
9477 {
9478   typedef NotEqualOptions Table;
9479   flatbuffers::FlatBufferBuilder &fbb_;
9480   flatbuffers::uoffset_t start_;
9481   explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9482   {
9483     start_ = fbb_.StartTable();
9484   }
9485   flatbuffers::Offset<NotEqualOptions> Finish()
9486   {
9487     const auto end = fbb_.EndTable(start_);
9488     auto o = flatbuffers::Offset<NotEqualOptions>(end);
9489     return o;
9490   }
9491 };
9492
9493 inline flatbuffers::Offset<NotEqualOptions>
9494 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
9495 {
9496   NotEqualOptionsBuilder builder_(_fbb);
9497   return builder_.Finish();
9498 }
9499
9500 flatbuffers::Offset<NotEqualOptions>
9501 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o,
9502                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9503
9504 struct ShapeOptionsT : public flatbuffers::NativeTable
9505 {
9506   typedef ShapeOptions TableType;
9507   circle::TensorType out_type = circle::TensorType_FLOAT32;
9508 };
9509
9510 struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9511 {
9512   typedef ShapeOptionsT NativeTableType;
9513   typedef ShapeOptionsBuilder Builder;
9514   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9515   {
9516     VT_OUT_TYPE = 4
9517   };
9518   circle::TensorType out_type() const
9519   {
9520     return static_cast<circle::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
9521   }
9522   bool Verify(flatbuffers::Verifier &verifier) const
9523   {
9524     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_OUT_TYPE) &&
9525            verifier.EndTable();
9526   }
9527   ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9528   void UnPackTo(ShapeOptionsT *_o,
9529                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9530   static flatbuffers::Offset<ShapeOptions>
9531   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o,
9532        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9533 };
9534
9535 struct ShapeOptionsBuilder
9536 {
9537   typedef ShapeOptions Table;
9538   flatbuffers::FlatBufferBuilder &fbb_;
9539   flatbuffers::uoffset_t start_;
9540   void add_out_type(circle::TensorType out_type)
9541   {
9542     fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
9543   }
9544   explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9545   {
9546     start_ = fbb_.StartTable();
9547   }
9548   flatbuffers::Offset<ShapeOptions> Finish()
9549   {
9550     const auto end = fbb_.EndTable(start_);
9551     auto o = flatbuffers::Offset<ShapeOptions>(end);
9552     return o;
9553   }
9554 };
9555
9556 inline flatbuffers::Offset<ShapeOptions>
9557 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb,
9558                    circle::TensorType out_type = circle::TensorType_FLOAT32)
9559 {
9560   ShapeOptionsBuilder builder_(_fbb);
9561   builder_.add_out_type(out_type);
9562   return builder_.Finish();
9563 }
9564
9565 flatbuffers::Offset<ShapeOptions>
9566 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o,
9567                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9568
9569 struct RankOptionsT : public flatbuffers::NativeTable
9570 {
9571   typedef RankOptions TableType;
9572 };
9573
9574 struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9575 {
9576   typedef RankOptionsT NativeTableType;
9577   typedef RankOptionsBuilder Builder;
9578   bool Verify(flatbuffers::Verifier &verifier) const
9579   {
9580     return VerifyTableStart(verifier) && verifier.EndTable();
9581   }
9582   RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9583   void UnPackTo(RankOptionsT *_o,
9584                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9585   static flatbuffers::Offset<RankOptions>
9586   Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o,
9587        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9588 };
9589
9590 struct RankOptionsBuilder
9591 {
9592   typedef RankOptions Table;
9593   flatbuffers::FlatBufferBuilder &fbb_;
9594   flatbuffers::uoffset_t start_;
9595   explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9596   {
9597     start_ = fbb_.StartTable();
9598   }
9599   flatbuffers::Offset<RankOptions> Finish()
9600   {
9601     const auto end = fbb_.EndTable(start_);
9602     auto o = flatbuffers::Offset<RankOptions>(end);
9603     return o;
9604   }
9605 };
9606
9607 inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb)
9608 {
9609   RankOptionsBuilder builder_(_fbb);
9610   return builder_.Finish();
9611 }
9612
9613 flatbuffers::Offset<RankOptions>
9614 CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o,
9615                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9616
9617 struct PowOptionsT : public flatbuffers::NativeTable
9618 {
9619   typedef PowOptions TableType;
9620 };
9621
9622 struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9623 {
9624   typedef PowOptionsT NativeTableType;
9625   typedef PowOptionsBuilder Builder;
9626   bool Verify(flatbuffers::Verifier &verifier) const
9627   {
9628     return VerifyTableStart(verifier) && verifier.EndTable();
9629   }
9630   PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9631   void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9632   static flatbuffers::Offset<PowOptions>
9633   Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o,
9634        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9635 };
9636
9637 struct PowOptionsBuilder
9638 {
9639   typedef PowOptions Table;
9640   flatbuffers::FlatBufferBuilder &fbb_;
9641   flatbuffers::uoffset_t start_;
9642   explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9643   {
9644     start_ = fbb_.StartTable();
9645   }
9646   flatbuffers::Offset<PowOptions> Finish()
9647   {
9648     const auto end = fbb_.EndTable(start_);
9649     auto o = flatbuffers::Offset<PowOptions>(end);
9650     return o;
9651   }
9652 };
9653
9654 inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb)
9655 {
9656   PowOptionsBuilder builder_(_fbb);
9657   return builder_.Finish();
9658 }
9659
9660 flatbuffers::Offset<PowOptions>
9661 CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o,
9662                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9663
9664 struct FakeQuantOptionsT : public flatbuffers::NativeTable
9665 {
9666   typedef FakeQuantOptions TableType;
9667   float min = 0.0f;
9668   float max = 0.0f;
9669   int32_t num_bits = 0;
9670   bool narrow_range = false;
9671 };
9672
9673 struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9674 {
9675   typedef FakeQuantOptionsT NativeTableType;
9676   typedef FakeQuantOptionsBuilder Builder;
9677   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9678   {
9679     VT_MIN = 4,
9680     VT_MAX = 6,
9681     VT_NUM_BITS = 8,
9682     VT_NARROW_RANGE = 10
9683   };
9684   float min() const { return GetField<float>(VT_MIN, 0.0f); }
9685   float max() const { return GetField<float>(VT_MAX, 0.0f); }
9686   int32_t num_bits() const { return GetField<int32_t>(VT_NUM_BITS, 0); }
9687   bool narrow_range() const { return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0; }
9688   bool Verify(flatbuffers::Verifier &verifier) const
9689   {
9690     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_MIN) &&
9691            VerifyField<float>(verifier, VT_MAX) && VerifyField<int32_t>(verifier, VT_NUM_BITS) &&
9692            VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) && verifier.EndTable();
9693   }
9694   FakeQuantOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9695   void UnPackTo(FakeQuantOptionsT *_o,
9696                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9697   static flatbuffers::Offset<FakeQuantOptions>
9698   Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o,
9699        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9700 };
9701
9702 struct FakeQuantOptionsBuilder
9703 {
9704   typedef FakeQuantOptions Table;
9705   flatbuffers::FlatBufferBuilder &fbb_;
9706   flatbuffers::uoffset_t start_;
9707   void add_min(float min) { fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f); }
9708   void add_max(float max) { fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f); }
9709   void add_num_bits(int32_t num_bits)
9710   {
9711     fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
9712   }
9713   void add_narrow_range(bool narrow_range)
9714   {
9715     fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range),
9716                              0);
9717   }
9718   explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9719   {
9720     start_ = fbb_.StartTable();
9721   }
9722   flatbuffers::Offset<FakeQuantOptions> Finish()
9723   {
9724     const auto end = fbb_.EndTable(start_);
9725     auto o = flatbuffers::Offset<FakeQuantOptions>(end);
9726     return o;
9727   }
9728 };
9729
9730 inline flatbuffers::Offset<FakeQuantOptions>
9731 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, float min = 0.0f, float max = 0.0f,
9732                        int32_t num_bits = 0, bool narrow_range = false)
9733 {
9734   FakeQuantOptionsBuilder builder_(_fbb);
9735   builder_.add_num_bits(num_bits);
9736   builder_.add_max(max);
9737   builder_.add_min(min);
9738   builder_.add_narrow_range(narrow_range);
9739   return builder_.Finish();
9740 }
9741
9742 flatbuffers::Offset<FakeQuantOptions>
9743 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o,
9744                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9745
9746 struct PackOptionsT : public flatbuffers::NativeTable
9747 {
9748   typedef PackOptions TableType;
9749   int32_t values_count = 0;
9750   int32_t axis = 0;
9751 };
9752
9753 struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9754 {
9755   typedef PackOptionsT NativeTableType;
9756   typedef PackOptionsBuilder Builder;
9757   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9758   {
9759     VT_VALUES_COUNT = 4,
9760     VT_AXIS = 6
9761   };
9762   int32_t values_count() const { return GetField<int32_t>(VT_VALUES_COUNT, 0); }
9763   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
9764   bool Verify(flatbuffers::Verifier &verifier) const
9765   {
9766     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_VALUES_COUNT) &&
9767            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
9768   }
9769   PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9770   void UnPackTo(PackOptionsT *_o,
9771                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9772   static flatbuffers::Offset<PackOptions>
9773   Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o,
9774        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9775 };
9776
9777 struct PackOptionsBuilder
9778 {
9779   typedef PackOptions Table;
9780   flatbuffers::FlatBufferBuilder &fbb_;
9781   flatbuffers::uoffset_t start_;
9782   void add_values_count(int32_t values_count)
9783   {
9784     fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
9785   }
9786   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0); }
9787   explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9788   {
9789     start_ = fbb_.StartTable();
9790   }
9791   flatbuffers::Offset<PackOptions> Finish()
9792   {
9793     const auto end = fbb_.EndTable(start_);
9794     auto o = flatbuffers::Offset<PackOptions>(end);
9795     return o;
9796   }
9797 };
9798
9799 inline flatbuffers::Offset<PackOptions>
9800 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count = 0, int32_t axis = 0)
9801 {
9802   PackOptionsBuilder builder_(_fbb);
9803   builder_.add_axis(axis);
9804   builder_.add_values_count(values_count);
9805   return builder_.Finish();
9806 }
9807
9808 flatbuffers::Offset<PackOptions>
9809 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o,
9810                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9811
9812 struct LogicalOrOptionsT : public flatbuffers::NativeTable
9813 {
9814   typedef LogicalOrOptions TableType;
9815 };
9816
9817 struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9818 {
9819   typedef LogicalOrOptionsT NativeTableType;
9820   typedef LogicalOrOptionsBuilder Builder;
9821   bool Verify(flatbuffers::Verifier &verifier) const
9822   {
9823     return VerifyTableStart(verifier) && verifier.EndTable();
9824   }
9825   LogicalOrOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9826   void UnPackTo(LogicalOrOptionsT *_o,
9827                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9828   static flatbuffers::Offset<LogicalOrOptions>
9829   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o,
9830        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9831 };
9832
9833 struct LogicalOrOptionsBuilder
9834 {
9835   typedef LogicalOrOptions Table;
9836   flatbuffers::FlatBufferBuilder &fbb_;
9837   flatbuffers::uoffset_t start_;
9838   explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9839   {
9840     start_ = fbb_.StartTable();
9841   }
9842   flatbuffers::Offset<LogicalOrOptions> Finish()
9843   {
9844     const auto end = fbb_.EndTable(start_);
9845     auto o = flatbuffers::Offset<LogicalOrOptions>(end);
9846     return o;
9847   }
9848 };
9849
9850 inline flatbuffers::Offset<LogicalOrOptions>
9851 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb)
9852 {
9853   LogicalOrOptionsBuilder builder_(_fbb);
9854   return builder_.Finish();
9855 }
9856
9857 flatbuffers::Offset<LogicalOrOptions>
9858 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o,
9859                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9860
9861 struct OneHotOptionsT : public flatbuffers::NativeTable
9862 {
9863   typedef OneHotOptions TableType;
9864   int32_t axis = 0;
9865 };
9866
9867 struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9868 {
9869   typedef OneHotOptionsT NativeTableType;
9870   typedef OneHotOptionsBuilder Builder;
9871   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
9872   {
9873     VT_AXIS = 4
9874   };
9875   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
9876   bool Verify(flatbuffers::Verifier &verifier) const
9877   {
9878     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_AXIS) &&
9879            verifier.EndTable();
9880   }
9881   OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9882   void UnPackTo(OneHotOptionsT *_o,
9883                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9884   static flatbuffers::Offset<OneHotOptions>
9885   Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o,
9886        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9887 };
9888
9889 struct OneHotOptionsBuilder
9890 {
9891   typedef OneHotOptions Table;
9892   flatbuffers::FlatBufferBuilder &fbb_;
9893   flatbuffers::uoffset_t start_;
9894   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0); }
9895   explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9896   {
9897     start_ = fbb_.StartTable();
9898   }
9899   flatbuffers::Offset<OneHotOptions> Finish()
9900   {
9901     const auto end = fbb_.EndTable(start_);
9902     auto o = flatbuffers::Offset<OneHotOptions>(end);
9903     return o;
9904   }
9905 };
9906
9907 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb,
9908                                                               int32_t axis = 0)
9909 {
9910   OneHotOptionsBuilder builder_(_fbb);
9911   builder_.add_axis(axis);
9912   return builder_.Finish();
9913 }
9914
9915 flatbuffers::Offset<OneHotOptions>
9916 CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o,
9917                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9918
9919 struct AbsOptionsT : public flatbuffers::NativeTable
9920 {
9921   typedef AbsOptions TableType;
9922 };
9923
9924 struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9925 {
9926   typedef AbsOptionsT NativeTableType;
9927   typedef AbsOptionsBuilder Builder;
9928   bool Verify(flatbuffers::Verifier &verifier) const
9929   {
9930     return VerifyTableStart(verifier) && verifier.EndTable();
9931   }
9932   AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9933   void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9934   static flatbuffers::Offset<AbsOptions>
9935   Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o,
9936        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9937 };
9938
9939 struct AbsOptionsBuilder
9940 {
9941   typedef AbsOptions Table;
9942   flatbuffers::FlatBufferBuilder &fbb_;
9943   flatbuffers::uoffset_t start_;
9944   explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9945   {
9946     start_ = fbb_.StartTable();
9947   }
9948   flatbuffers::Offset<AbsOptions> Finish()
9949   {
9950     const auto end = fbb_.EndTable(start_);
9951     auto o = flatbuffers::Offset<AbsOptions>(end);
9952     return o;
9953   }
9954 };
9955
9956 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb)
9957 {
9958   AbsOptionsBuilder builder_(_fbb);
9959   return builder_.Finish();
9960 }
9961
9962 flatbuffers::Offset<AbsOptions>
9963 CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o,
9964                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9965
9966 struct HardSwishOptionsT : public flatbuffers::NativeTable
9967 {
9968   typedef HardSwishOptions TableType;
9969 };
9970
9971 struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
9972 {
9973   typedef HardSwishOptionsT NativeTableType;
9974   typedef HardSwishOptionsBuilder Builder;
9975   bool Verify(flatbuffers::Verifier &verifier) const
9976   {
9977     return VerifyTableStart(verifier) && verifier.EndTable();
9978   }
9979   HardSwishOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9980   void UnPackTo(HardSwishOptionsT *_o,
9981                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9982   static flatbuffers::Offset<HardSwishOptions>
9983   Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o,
9984        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9985 };
9986
9987 struct HardSwishOptionsBuilder
9988 {
9989   typedef HardSwishOptions Table;
9990   flatbuffers::FlatBufferBuilder &fbb_;
9991   flatbuffers::uoffset_t start_;
9992   explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
9993   {
9994     start_ = fbb_.StartTable();
9995   }
9996   flatbuffers::Offset<HardSwishOptions> Finish()
9997   {
9998     const auto end = fbb_.EndTable(start_);
9999     auto o = flatbuffers::Offset<HardSwishOptions>(end);
10000     return o;
10001   }
10002 };
10003
10004 inline flatbuffers::Offset<HardSwishOptions>
10005 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb)
10006 {
10007   HardSwishOptionsBuilder builder_(_fbb);
10008   return builder_.Finish();
10009 }
10010
10011 flatbuffers::Offset<HardSwishOptions>
10012 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o,
10013                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10014
10015 struct LogicalAndOptionsT : public flatbuffers::NativeTable
10016 {
10017   typedef LogicalAndOptions TableType;
10018 };
10019
10020 struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10021 {
10022   typedef LogicalAndOptionsT NativeTableType;
10023   typedef LogicalAndOptionsBuilder Builder;
10024   bool Verify(flatbuffers::Verifier &verifier) const
10025   {
10026     return VerifyTableStart(verifier) && verifier.EndTable();
10027   }
10028   LogicalAndOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10029   void UnPackTo(LogicalAndOptionsT *_o,
10030                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10031   static flatbuffers::Offset<LogicalAndOptions>
10032   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o,
10033        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10034 };
10035
10036 struct LogicalAndOptionsBuilder
10037 {
10038   typedef LogicalAndOptions Table;
10039   flatbuffers::FlatBufferBuilder &fbb_;
10040   flatbuffers::uoffset_t start_;
10041   explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10042   {
10043     start_ = fbb_.StartTable();
10044   }
10045   flatbuffers::Offset<LogicalAndOptions> Finish()
10046   {
10047     const auto end = fbb_.EndTable(start_);
10048     auto o = flatbuffers::Offset<LogicalAndOptions>(end);
10049     return o;
10050   }
10051 };
10052
10053 inline flatbuffers::Offset<LogicalAndOptions>
10054 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb)
10055 {
10056   LogicalAndOptionsBuilder builder_(_fbb);
10057   return builder_.Finish();
10058 }
10059
10060 flatbuffers::Offset<LogicalAndOptions>
10061 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o,
10062                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10063
10064 struct LogicalNotOptionsT : public flatbuffers::NativeTable
10065 {
10066   typedef LogicalNotOptions TableType;
10067 };
10068
10069 struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10070 {
10071   typedef LogicalNotOptionsT NativeTableType;
10072   typedef LogicalNotOptionsBuilder Builder;
10073   bool Verify(flatbuffers::Verifier &verifier) const
10074   {
10075     return VerifyTableStart(verifier) && verifier.EndTable();
10076   }
10077   LogicalNotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10078   void UnPackTo(LogicalNotOptionsT *_o,
10079                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10080   static flatbuffers::Offset<LogicalNotOptions>
10081   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o,
10082        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10083 };
10084
10085 struct LogicalNotOptionsBuilder
10086 {
10087   typedef LogicalNotOptions Table;
10088   flatbuffers::FlatBufferBuilder &fbb_;
10089   flatbuffers::uoffset_t start_;
10090   explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10091   {
10092     start_ = fbb_.StartTable();
10093   }
10094   flatbuffers::Offset<LogicalNotOptions> Finish()
10095   {
10096     const auto end = fbb_.EndTable(start_);
10097     auto o = flatbuffers::Offset<LogicalNotOptions>(end);
10098     return o;
10099   }
10100 };
10101
10102 inline flatbuffers::Offset<LogicalNotOptions>
10103 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb)
10104 {
10105   LogicalNotOptionsBuilder builder_(_fbb);
10106   return builder_.Finish();
10107 }
10108
10109 flatbuffers::Offset<LogicalNotOptions>
10110 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o,
10111                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10112
10113 struct UnpackOptionsT : public flatbuffers::NativeTable
10114 {
10115   typedef UnpackOptions TableType;
10116   int32_t num = 0;
10117   int32_t axis = 0;
10118 };
10119
10120 struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10121 {
10122   typedef UnpackOptionsT NativeTableType;
10123   typedef UnpackOptionsBuilder Builder;
10124   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10125   {
10126     VT_NUM = 4,
10127     VT_AXIS = 6
10128   };
10129   int32_t num() const { return GetField<int32_t>(VT_NUM, 0); }
10130   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
10131   bool Verify(flatbuffers::Verifier &verifier) const
10132   {
10133     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_NUM) &&
10134            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
10135   }
10136   UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10137   void UnPackTo(UnpackOptionsT *_o,
10138                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10139   static flatbuffers::Offset<UnpackOptions>
10140   Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o,
10141        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10142 };
10143
10144 struct UnpackOptionsBuilder
10145 {
10146   typedef UnpackOptions Table;
10147   flatbuffers::FlatBufferBuilder &fbb_;
10148   flatbuffers::uoffset_t start_;
10149   void add_num(int32_t num) { fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0); }
10150   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0); }
10151   explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10152   {
10153     start_ = fbb_.StartTable();
10154   }
10155   flatbuffers::Offset<UnpackOptions> Finish()
10156   {
10157     const auto end = fbb_.EndTable(start_);
10158     auto o = flatbuffers::Offset<UnpackOptions>(end);
10159     return o;
10160   }
10161 };
10162
10163 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb,
10164                                                               int32_t num = 0, int32_t axis = 0)
10165 {
10166   UnpackOptionsBuilder builder_(_fbb);
10167   builder_.add_axis(axis);
10168   builder_.add_num(num);
10169   return builder_.Finish();
10170 }
10171
10172 flatbuffers::Offset<UnpackOptions>
10173 CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o,
10174                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10175
10176 struct FloorDivOptionsT : public flatbuffers::NativeTable
10177 {
10178   typedef FloorDivOptions TableType;
10179 };
10180
10181 struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10182 {
10183   typedef FloorDivOptionsT NativeTableType;
10184   typedef FloorDivOptionsBuilder Builder;
10185   bool Verify(flatbuffers::Verifier &verifier) const
10186   {
10187     return VerifyTableStart(verifier) && verifier.EndTable();
10188   }
10189   FloorDivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10190   void UnPackTo(FloorDivOptionsT *_o,
10191                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10192   static flatbuffers::Offset<FloorDivOptions>
10193   Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o,
10194        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10195 };
10196
10197 struct FloorDivOptionsBuilder
10198 {
10199   typedef FloorDivOptions Table;
10200   flatbuffers::FlatBufferBuilder &fbb_;
10201   flatbuffers::uoffset_t start_;
10202   explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10203   {
10204     start_ = fbb_.StartTable();
10205   }
10206   flatbuffers::Offset<FloorDivOptions> Finish()
10207   {
10208     const auto end = fbb_.EndTable(start_);
10209     auto o = flatbuffers::Offset<FloorDivOptions>(end);
10210     return o;
10211   }
10212 };
10213
10214 inline flatbuffers::Offset<FloorDivOptions>
10215 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb)
10216 {
10217   FloorDivOptionsBuilder builder_(_fbb);
10218   return builder_.Finish();
10219 }
10220
10221 flatbuffers::Offset<FloorDivOptions>
10222 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o,
10223                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10224
10225 struct SquareOptionsT : public flatbuffers::NativeTable
10226 {
10227   typedef SquareOptions TableType;
10228 };
10229
10230 struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10231 {
10232   typedef SquareOptionsT NativeTableType;
10233   typedef SquareOptionsBuilder Builder;
10234   bool Verify(flatbuffers::Verifier &verifier) const
10235   {
10236     return VerifyTableStart(verifier) && verifier.EndTable();
10237   }
10238   SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10239   void UnPackTo(SquareOptionsT *_o,
10240                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10241   static flatbuffers::Offset<SquareOptions>
10242   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o,
10243        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10244 };
10245
10246 struct SquareOptionsBuilder
10247 {
10248   typedef SquareOptions Table;
10249   flatbuffers::FlatBufferBuilder &fbb_;
10250   flatbuffers::uoffset_t start_;
10251   explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10252   {
10253     start_ = fbb_.StartTable();
10254   }
10255   flatbuffers::Offset<SquareOptions> Finish()
10256   {
10257     const auto end = fbb_.EndTable(start_);
10258     auto o = flatbuffers::Offset<SquareOptions>(end);
10259     return o;
10260   }
10261 };
10262
10263 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb)
10264 {
10265   SquareOptionsBuilder builder_(_fbb);
10266   return builder_.Finish();
10267 }
10268
10269 flatbuffers::Offset<SquareOptions>
10270 CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o,
10271                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10272
10273 struct ZerosLikeOptionsT : public flatbuffers::NativeTable
10274 {
10275   typedef ZerosLikeOptions TableType;
10276 };
10277
10278 struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10279 {
10280   typedef ZerosLikeOptionsT NativeTableType;
10281   typedef ZerosLikeOptionsBuilder Builder;
10282   bool Verify(flatbuffers::Verifier &verifier) const
10283   {
10284     return VerifyTableStart(verifier) && verifier.EndTable();
10285   }
10286   ZerosLikeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10287   void UnPackTo(ZerosLikeOptionsT *_o,
10288                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10289   static flatbuffers::Offset<ZerosLikeOptions>
10290   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o,
10291        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10292 };
10293
10294 struct ZerosLikeOptionsBuilder
10295 {
10296   typedef ZerosLikeOptions Table;
10297   flatbuffers::FlatBufferBuilder &fbb_;
10298   flatbuffers::uoffset_t start_;
10299   explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10300   {
10301     start_ = fbb_.StartTable();
10302   }
10303   flatbuffers::Offset<ZerosLikeOptions> Finish()
10304   {
10305     const auto end = fbb_.EndTable(start_);
10306     auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
10307     return o;
10308   }
10309 };
10310
10311 inline flatbuffers::Offset<ZerosLikeOptions>
10312 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb)
10313 {
10314   ZerosLikeOptionsBuilder builder_(_fbb);
10315   return builder_.Finish();
10316 }
10317
10318 flatbuffers::Offset<ZerosLikeOptions>
10319 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o,
10320                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10321
10322 struct FillOptionsT : public flatbuffers::NativeTable
10323 {
10324   typedef FillOptions TableType;
10325 };
10326
10327 struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10328 {
10329   typedef FillOptionsT NativeTableType;
10330   typedef FillOptionsBuilder Builder;
10331   bool Verify(flatbuffers::Verifier &verifier) const
10332   {
10333     return VerifyTableStart(verifier) && verifier.EndTable();
10334   }
10335   FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10336   void UnPackTo(FillOptionsT *_o,
10337                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10338   static flatbuffers::Offset<FillOptions>
10339   Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o,
10340        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10341 };
10342
10343 struct FillOptionsBuilder
10344 {
10345   typedef FillOptions Table;
10346   flatbuffers::FlatBufferBuilder &fbb_;
10347   flatbuffers::uoffset_t start_;
10348   explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10349   {
10350     start_ = fbb_.StartTable();
10351   }
10352   flatbuffers::Offset<FillOptions> Finish()
10353   {
10354     const auto end = fbb_.EndTable(start_);
10355     auto o = flatbuffers::Offset<FillOptions>(end);
10356     return o;
10357   }
10358 };
10359
10360 inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb)
10361 {
10362   FillOptionsBuilder builder_(_fbb);
10363   return builder_.Finish();
10364 }
10365
10366 flatbuffers::Offset<FillOptions>
10367 CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o,
10368                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10369
10370 struct FloorModOptionsT : public flatbuffers::NativeTable
10371 {
10372   typedef FloorModOptions TableType;
10373 };
10374
10375 struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10376 {
10377   typedef FloorModOptionsT NativeTableType;
10378   typedef FloorModOptionsBuilder Builder;
10379   bool Verify(flatbuffers::Verifier &verifier) const
10380   {
10381     return VerifyTableStart(verifier) && verifier.EndTable();
10382   }
10383   FloorModOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10384   void UnPackTo(FloorModOptionsT *_o,
10385                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10386   static flatbuffers::Offset<FloorModOptions>
10387   Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o,
10388        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10389 };
10390
10391 struct FloorModOptionsBuilder
10392 {
10393   typedef FloorModOptions Table;
10394   flatbuffers::FlatBufferBuilder &fbb_;
10395   flatbuffers::uoffset_t start_;
10396   explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10397   {
10398     start_ = fbb_.StartTable();
10399   }
10400   flatbuffers::Offset<FloorModOptions> Finish()
10401   {
10402     const auto end = fbb_.EndTable(start_);
10403     auto o = flatbuffers::Offset<FloorModOptions>(end);
10404     return o;
10405   }
10406 };
10407
10408 inline flatbuffers::Offset<FloorModOptions>
10409 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb)
10410 {
10411   FloorModOptionsBuilder builder_(_fbb);
10412   return builder_.Finish();
10413 }
10414
10415 flatbuffers::Offset<FloorModOptions>
10416 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o,
10417                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10418
10419 struct RangeOptionsT : public flatbuffers::NativeTable
10420 {
10421   typedef RangeOptions TableType;
10422 };
10423
10424 struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10425 {
10426   typedef RangeOptionsT NativeTableType;
10427   typedef RangeOptionsBuilder Builder;
10428   bool Verify(flatbuffers::Verifier &verifier) const
10429   {
10430     return VerifyTableStart(verifier) && verifier.EndTable();
10431   }
10432   RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10433   void UnPackTo(RangeOptionsT *_o,
10434                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10435   static flatbuffers::Offset<RangeOptions>
10436   Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o,
10437        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10438 };
10439
10440 struct RangeOptionsBuilder
10441 {
10442   typedef RangeOptions Table;
10443   flatbuffers::FlatBufferBuilder &fbb_;
10444   flatbuffers::uoffset_t start_;
10445   explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10446   {
10447     start_ = fbb_.StartTable();
10448   }
10449   flatbuffers::Offset<RangeOptions> Finish()
10450   {
10451     const auto end = fbb_.EndTable(start_);
10452     auto o = flatbuffers::Offset<RangeOptions>(end);
10453     return o;
10454   }
10455 };
10456
10457 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb)
10458 {
10459   RangeOptionsBuilder builder_(_fbb);
10460   return builder_.Finish();
10461 }
10462
10463 flatbuffers::Offset<RangeOptions>
10464 CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o,
10465                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10466
10467 struct LeakyReluOptionsT : public flatbuffers::NativeTable
10468 {
10469   typedef LeakyReluOptions TableType;
10470   float alpha = 0.0f;
10471 };
10472
10473 struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10474 {
10475   typedef LeakyReluOptionsT NativeTableType;
10476   typedef LeakyReluOptionsBuilder Builder;
10477   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10478   {
10479     VT_ALPHA = 4
10480   };
10481   float alpha() const { return GetField<float>(VT_ALPHA, 0.0f); }
10482   bool Verify(flatbuffers::Verifier &verifier) const
10483   {
10484     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_ALPHA) &&
10485            verifier.EndTable();
10486   }
10487   LeakyReluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10488   void UnPackTo(LeakyReluOptionsT *_o,
10489                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10490   static flatbuffers::Offset<LeakyReluOptions>
10491   Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o,
10492        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10493 };
10494
10495 struct LeakyReluOptionsBuilder
10496 {
10497   typedef LeakyReluOptions Table;
10498   flatbuffers::FlatBufferBuilder &fbb_;
10499   flatbuffers::uoffset_t start_;
10500   void add_alpha(float alpha) { fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); }
10501   explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10502   {
10503     start_ = fbb_.StartTable();
10504   }
10505   flatbuffers::Offset<LeakyReluOptions> Finish()
10506   {
10507     const auto end = fbb_.EndTable(start_);
10508     auto o = flatbuffers::Offset<LeakyReluOptions>(end);
10509     return o;
10510   }
10511 };
10512
10513 inline flatbuffers::Offset<LeakyReluOptions>
10514 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, float alpha = 0.0f)
10515 {
10516   LeakyReluOptionsBuilder builder_(_fbb);
10517   builder_.add_alpha(alpha);
10518   return builder_.Finish();
10519 }
10520
10521 flatbuffers::Offset<LeakyReluOptions>
10522 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o,
10523                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10524
10525 struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable
10526 {
10527   typedef SquaredDifferenceOptions TableType;
10528 };
10529
10530 struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10531 {
10532   typedef SquaredDifferenceOptionsT NativeTableType;
10533   typedef SquaredDifferenceOptionsBuilder Builder;
10534   bool Verify(flatbuffers::Verifier &verifier) const
10535   {
10536     return VerifyTableStart(verifier) && verifier.EndTable();
10537   }
10538   SquaredDifferenceOptionsT *
10539   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10540   void UnPackTo(SquaredDifferenceOptionsT *_o,
10541                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10542   static flatbuffers::Offset<SquaredDifferenceOptions>
10543   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o,
10544        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10545 };
10546
10547 struct SquaredDifferenceOptionsBuilder
10548 {
10549   typedef SquaredDifferenceOptions Table;
10550   flatbuffers::FlatBufferBuilder &fbb_;
10551   flatbuffers::uoffset_t start_;
10552   explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10553   {
10554     start_ = fbb_.StartTable();
10555   }
10556   flatbuffers::Offset<SquaredDifferenceOptions> Finish()
10557   {
10558     const auto end = fbb_.EndTable(start_);
10559     auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
10560     return o;
10561   }
10562 };
10563
10564 inline flatbuffers::Offset<SquaredDifferenceOptions>
10565 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb)
10566 {
10567   SquaredDifferenceOptionsBuilder builder_(_fbb);
10568   return builder_.Finish();
10569 }
10570
10571 flatbuffers::Offset<SquaredDifferenceOptions>
10572 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb,
10573                                const SquaredDifferenceOptionsT *_o,
10574                                const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10575
10576 struct MirrorPadOptionsT : public flatbuffers::NativeTable
10577 {
10578   typedef MirrorPadOptions TableType;
10579   circle::MirrorPadMode mode = circle::MirrorPadMode_REFLECT;
10580 };
10581
10582 struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10583 {
10584   typedef MirrorPadOptionsT NativeTableType;
10585   typedef MirrorPadOptionsBuilder Builder;
10586   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10587   {
10588     VT_MODE = 4
10589   };
10590   circle::MirrorPadMode mode() const
10591   {
10592     return static_cast<circle::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
10593   }
10594   bool Verify(flatbuffers::Verifier &verifier) const
10595   {
10596     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_MODE) &&
10597            verifier.EndTable();
10598   }
10599   MirrorPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10600   void UnPackTo(MirrorPadOptionsT *_o,
10601                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10602   static flatbuffers::Offset<MirrorPadOptions>
10603   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o,
10604        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10605 };
10606
10607 struct MirrorPadOptionsBuilder
10608 {
10609   typedef MirrorPadOptions Table;
10610   flatbuffers::FlatBufferBuilder &fbb_;
10611   flatbuffers::uoffset_t start_;
10612   void add_mode(circle::MirrorPadMode mode)
10613   {
10614     fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
10615   }
10616   explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10617   {
10618     start_ = fbb_.StartTable();
10619   }
10620   flatbuffers::Offset<MirrorPadOptions> Finish()
10621   {
10622     const auto end = fbb_.EndTable(start_);
10623     auto o = flatbuffers::Offset<MirrorPadOptions>(end);
10624     return o;
10625   }
10626 };
10627
10628 inline flatbuffers::Offset<MirrorPadOptions>
10629 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb,
10630                        circle::MirrorPadMode mode = circle::MirrorPadMode_REFLECT)
10631 {
10632   MirrorPadOptionsBuilder builder_(_fbb);
10633   builder_.add_mode(mode);
10634   return builder_.Finish();
10635 }
10636
10637 flatbuffers::Offset<MirrorPadOptions>
10638 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o,
10639                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10640
10641 struct UniqueOptionsT : public flatbuffers::NativeTable
10642 {
10643   typedef UniqueOptions TableType;
10644   circle::TensorType idx_out_type = circle::TensorType_INT32;
10645 };
10646
10647 struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10648 {
10649   typedef UniqueOptionsT NativeTableType;
10650   typedef UniqueOptionsBuilder Builder;
10651   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10652   {
10653     VT_IDX_OUT_TYPE = 4
10654   };
10655   circle::TensorType idx_out_type() const
10656   {
10657     return static_cast<circle::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
10658   }
10659   bool Verify(flatbuffers::Verifier &verifier) const
10660   {
10661     return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) &&
10662            verifier.EndTable();
10663   }
10664   UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10665   void UnPackTo(UniqueOptionsT *_o,
10666                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10667   static flatbuffers::Offset<UniqueOptions>
10668   Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o,
10669        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10670 };
10671
10672 struct UniqueOptionsBuilder
10673 {
10674   typedef UniqueOptions Table;
10675   flatbuffers::FlatBufferBuilder &fbb_;
10676   flatbuffers::uoffset_t start_;
10677   void add_idx_out_type(circle::TensorType idx_out_type)
10678   {
10679     fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
10680   }
10681   explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10682   {
10683     start_ = fbb_.StartTable();
10684   }
10685   flatbuffers::Offset<UniqueOptions> Finish()
10686   {
10687     const auto end = fbb_.EndTable(start_);
10688     auto o = flatbuffers::Offset<UniqueOptions>(end);
10689     return o;
10690   }
10691 };
10692
10693 inline flatbuffers::Offset<UniqueOptions>
10694 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb,
10695                     circle::TensorType idx_out_type = circle::TensorType_INT32)
10696 {
10697   UniqueOptionsBuilder builder_(_fbb);
10698   builder_.add_idx_out_type(idx_out_type);
10699   return builder_.Finish();
10700 }
10701
10702 flatbuffers::Offset<UniqueOptions>
10703 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o,
10704                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10705
10706 struct ReverseV2OptionsT : public flatbuffers::NativeTable
10707 {
10708   typedef ReverseV2Options TableType;
10709 };
10710
10711 struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10712 {
10713   typedef ReverseV2OptionsT NativeTableType;
10714   typedef ReverseV2OptionsBuilder Builder;
10715   bool Verify(flatbuffers::Verifier &verifier) const
10716   {
10717     return VerifyTableStart(verifier) && verifier.EndTable();
10718   }
10719   ReverseV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10720   void UnPackTo(ReverseV2OptionsT *_o,
10721                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10722   static flatbuffers::Offset<ReverseV2Options>
10723   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o,
10724        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10725 };
10726
10727 struct ReverseV2OptionsBuilder
10728 {
10729   typedef ReverseV2Options Table;
10730   flatbuffers::FlatBufferBuilder &fbb_;
10731   flatbuffers::uoffset_t start_;
10732   explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10733   {
10734     start_ = fbb_.StartTable();
10735   }
10736   flatbuffers::Offset<ReverseV2Options> Finish()
10737   {
10738     const auto end = fbb_.EndTable(start_);
10739     auto o = flatbuffers::Offset<ReverseV2Options>(end);
10740     return o;
10741   }
10742 };
10743
10744 inline flatbuffers::Offset<ReverseV2Options>
10745 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb)
10746 {
10747   ReverseV2OptionsBuilder builder_(_fbb);
10748   return builder_.Finish();
10749 }
10750
10751 flatbuffers::Offset<ReverseV2Options>
10752 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o,
10753                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10754
10755 struct AddNOptionsT : public flatbuffers::NativeTable
10756 {
10757   typedef AddNOptions TableType;
10758 };
10759
10760 struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10761 {
10762   typedef AddNOptionsT NativeTableType;
10763   typedef AddNOptionsBuilder Builder;
10764   bool Verify(flatbuffers::Verifier &verifier) const
10765   {
10766     return VerifyTableStart(verifier) && verifier.EndTable();
10767   }
10768   AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10769   void UnPackTo(AddNOptionsT *_o,
10770                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10771   static flatbuffers::Offset<AddNOptions>
10772   Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o,
10773        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10774 };
10775
10776 struct AddNOptionsBuilder
10777 {
10778   typedef AddNOptions Table;
10779   flatbuffers::FlatBufferBuilder &fbb_;
10780   flatbuffers::uoffset_t start_;
10781   explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10782   {
10783     start_ = fbb_.StartTable();
10784   }
10785   flatbuffers::Offset<AddNOptions> Finish()
10786   {
10787     const auto end = fbb_.EndTable(start_);
10788     auto o = flatbuffers::Offset<AddNOptions>(end);
10789     return o;
10790   }
10791 };
10792
10793 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb)
10794 {
10795   AddNOptionsBuilder builder_(_fbb);
10796   return builder_.Finish();
10797 }
10798
10799 flatbuffers::Offset<AddNOptions>
10800 CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o,
10801                   const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10802
10803 struct GatherNdOptionsT : public flatbuffers::NativeTable
10804 {
10805   typedef GatherNdOptions TableType;
10806 };
10807
10808 struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10809 {
10810   typedef GatherNdOptionsT NativeTableType;
10811   typedef GatherNdOptionsBuilder Builder;
10812   bool Verify(flatbuffers::Verifier &verifier) const
10813   {
10814     return VerifyTableStart(verifier) && verifier.EndTable();
10815   }
10816   GatherNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10817   void UnPackTo(GatherNdOptionsT *_o,
10818                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10819   static flatbuffers::Offset<GatherNdOptions>
10820   Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o,
10821        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10822 };
10823
10824 struct GatherNdOptionsBuilder
10825 {
10826   typedef GatherNdOptions Table;
10827   flatbuffers::FlatBufferBuilder &fbb_;
10828   flatbuffers::uoffset_t start_;
10829   explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10830   {
10831     start_ = fbb_.StartTable();
10832   }
10833   flatbuffers::Offset<GatherNdOptions> Finish()
10834   {
10835     const auto end = fbb_.EndTable(start_);
10836     auto o = flatbuffers::Offset<GatherNdOptions>(end);
10837     return o;
10838   }
10839 };
10840
10841 inline flatbuffers::Offset<GatherNdOptions>
10842 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
10843 {
10844   GatherNdOptionsBuilder builder_(_fbb);
10845   return builder_.Finish();
10846 }
10847
10848 flatbuffers::Offset<GatherNdOptions>
10849 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o,
10850                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10851
10852 struct WhereOptionsT : public flatbuffers::NativeTable
10853 {
10854   typedef WhereOptions TableType;
10855 };
10856
10857 struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10858 {
10859   typedef WhereOptionsT NativeTableType;
10860   typedef WhereOptionsBuilder Builder;
10861   bool Verify(flatbuffers::Verifier &verifier) const
10862   {
10863     return VerifyTableStart(verifier) && verifier.EndTable();
10864   }
10865   WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10866   void UnPackTo(WhereOptionsT *_o,
10867                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10868   static flatbuffers::Offset<WhereOptions>
10869   Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o,
10870        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10871 };
10872
10873 struct WhereOptionsBuilder
10874 {
10875   typedef WhereOptions Table;
10876   flatbuffers::FlatBufferBuilder &fbb_;
10877   flatbuffers::uoffset_t start_;
10878   explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10879   {
10880     start_ = fbb_.StartTable();
10881   }
10882   flatbuffers::Offset<WhereOptions> Finish()
10883   {
10884     const auto end = fbb_.EndTable(start_);
10885     auto o = flatbuffers::Offset<WhereOptions>(end);
10886     return o;
10887   }
10888 };
10889
10890 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb)
10891 {
10892   WhereOptionsBuilder builder_(_fbb);
10893   return builder_.Finish();
10894 }
10895
10896 flatbuffers::Offset<WhereOptions>
10897 CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o,
10898                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10899
10900 struct ReverseSequenceOptionsT : public flatbuffers::NativeTable
10901 {
10902   typedef ReverseSequenceOptions TableType;
10903   int32_t seq_dim = 0;
10904   int32_t batch_dim = 0;
10905 };
10906
10907 struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10908 {
10909   typedef ReverseSequenceOptionsT NativeTableType;
10910   typedef ReverseSequenceOptionsBuilder Builder;
10911   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
10912   {
10913     VT_SEQ_DIM = 4,
10914     VT_BATCH_DIM = 6
10915   };
10916   int32_t seq_dim() const { return GetField<int32_t>(VT_SEQ_DIM, 0); }
10917   int32_t batch_dim() const { return GetField<int32_t>(VT_BATCH_DIM, 0); }
10918   bool Verify(flatbuffers::Verifier &verifier) const
10919   {
10920     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_SEQ_DIM) &&
10921            VerifyField<int32_t>(verifier, VT_BATCH_DIM) && verifier.EndTable();
10922   }
10923   ReverseSequenceOptionsT *
10924   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10925   void UnPackTo(ReverseSequenceOptionsT *_o,
10926                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10927   static flatbuffers::Offset<ReverseSequenceOptions>
10928   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o,
10929        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10930 };
10931
10932 struct ReverseSequenceOptionsBuilder
10933 {
10934   typedef ReverseSequenceOptions Table;
10935   flatbuffers::FlatBufferBuilder &fbb_;
10936   flatbuffers::uoffset_t start_;
10937   void add_seq_dim(int32_t seq_dim)
10938   {
10939     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
10940   }
10941   void add_batch_dim(int32_t batch_dim)
10942   {
10943     fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
10944   }
10945   explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10946   {
10947     start_ = fbb_.StartTable();
10948   }
10949   flatbuffers::Offset<ReverseSequenceOptions> Finish()
10950   {
10951     const auto end = fbb_.EndTable(start_);
10952     auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
10953     return o;
10954   }
10955 };
10956
10957 inline flatbuffers::Offset<ReverseSequenceOptions>
10958 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim = 0,
10959                              int32_t batch_dim = 0)
10960 {
10961   ReverseSequenceOptionsBuilder builder_(_fbb);
10962   builder_.add_batch_dim(batch_dim);
10963   builder_.add_seq_dim(seq_dim);
10964   return builder_.Finish();
10965 }
10966
10967 flatbuffers::Offset<ReverseSequenceOptions>
10968 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb,
10969                              const ReverseSequenceOptionsT *_o,
10970                              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10971
10972 struct MatrixDiagOptionsT : public flatbuffers::NativeTable
10973 {
10974   typedef MatrixDiagOptions TableType;
10975 };
10976
10977 struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
10978 {
10979   typedef MatrixDiagOptionsT NativeTableType;
10980   typedef MatrixDiagOptionsBuilder Builder;
10981   bool Verify(flatbuffers::Verifier &verifier) const
10982   {
10983     return VerifyTableStart(verifier) && verifier.EndTable();
10984   }
10985   MatrixDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10986   void UnPackTo(MatrixDiagOptionsT *_o,
10987                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10988   static flatbuffers::Offset<MatrixDiagOptions>
10989   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o,
10990        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10991 };
10992
10993 struct MatrixDiagOptionsBuilder
10994 {
10995   typedef MatrixDiagOptions Table;
10996   flatbuffers::FlatBufferBuilder &fbb_;
10997   flatbuffers::uoffset_t start_;
10998   explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
10999   {
11000     start_ = fbb_.StartTable();
11001   }
11002   flatbuffers::Offset<MatrixDiagOptions> Finish()
11003   {
11004     const auto end = fbb_.EndTable(start_);
11005     auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
11006     return o;
11007   }
11008 };
11009
11010 inline flatbuffers::Offset<MatrixDiagOptions>
11011 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
11012 {
11013   MatrixDiagOptionsBuilder builder_(_fbb);
11014   return builder_.Finish();
11015 }
11016
11017 flatbuffers::Offset<MatrixDiagOptions>
11018 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o,
11019                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11020
11021 struct QuantizeOptionsT : public flatbuffers::NativeTable
11022 {
11023   typedef QuantizeOptions TableType;
11024 };
11025
11026 struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11027 {
11028   typedef QuantizeOptionsT NativeTableType;
11029   typedef QuantizeOptionsBuilder Builder;
11030   bool Verify(flatbuffers::Verifier &verifier) const
11031   {
11032     return VerifyTableStart(verifier) && verifier.EndTable();
11033   }
11034   QuantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11035   void UnPackTo(QuantizeOptionsT *_o,
11036                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11037   static flatbuffers::Offset<QuantizeOptions>
11038   Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o,
11039        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11040 };
11041
11042 struct QuantizeOptionsBuilder
11043 {
11044   typedef QuantizeOptions Table;
11045   flatbuffers::FlatBufferBuilder &fbb_;
11046   flatbuffers::uoffset_t start_;
11047   explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11048   {
11049     start_ = fbb_.StartTable();
11050   }
11051   flatbuffers::Offset<QuantizeOptions> Finish()
11052   {
11053     const auto end = fbb_.EndTable(start_);
11054     auto o = flatbuffers::Offset<QuantizeOptions>(end);
11055     return o;
11056   }
11057 };
11058
11059 inline flatbuffers::Offset<QuantizeOptions>
11060 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
11061 {
11062   QuantizeOptionsBuilder builder_(_fbb);
11063   return builder_.Finish();
11064 }
11065
11066 flatbuffers::Offset<QuantizeOptions>
11067 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o,
11068                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11069
11070 struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable
11071 {
11072   typedef MatrixSetDiagOptions TableType;
11073 };
11074
11075 struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11076 {
11077   typedef MatrixSetDiagOptionsT NativeTableType;
11078   typedef MatrixSetDiagOptionsBuilder Builder;
11079   bool Verify(flatbuffers::Verifier &verifier) const
11080   {
11081     return VerifyTableStart(verifier) && verifier.EndTable();
11082   }
11083   MatrixSetDiagOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11084   void UnPackTo(MatrixSetDiagOptionsT *_o,
11085                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11086   static flatbuffers::Offset<MatrixSetDiagOptions>
11087   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o,
11088        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11089 };
11090
11091 struct MatrixSetDiagOptionsBuilder
11092 {
11093   typedef MatrixSetDiagOptions Table;
11094   flatbuffers::FlatBufferBuilder &fbb_;
11095   flatbuffers::uoffset_t start_;
11096   explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11097   {
11098     start_ = fbb_.StartTable();
11099   }
11100   flatbuffers::Offset<MatrixSetDiagOptions> Finish()
11101   {
11102     const auto end = fbb_.EndTable(start_);
11103     auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
11104     return o;
11105   }
11106 };
11107
11108 inline flatbuffers::Offset<MatrixSetDiagOptions>
11109 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
11110 {
11111   MatrixSetDiagOptionsBuilder builder_(_fbb);
11112   return builder_.Finish();
11113 }
11114
11115 flatbuffers::Offset<MatrixSetDiagOptions>
11116 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o,
11117                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11118
11119 struct IfOptionsT : public flatbuffers::NativeTable
11120 {
11121   typedef IfOptions TableType;
11122   int32_t then_subgraph_index = 0;
11123   int32_t else_subgraph_index = 0;
11124 };
11125
11126 struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11127 {
11128   typedef IfOptionsT NativeTableType;
11129   typedef IfOptionsBuilder Builder;
11130   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11131   {
11132     VT_THEN_SUBGRAPH_INDEX = 4,
11133     VT_ELSE_SUBGRAPH_INDEX = 6
11134   };
11135   int32_t then_subgraph_index() const { return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0); }
11136   int32_t else_subgraph_index() const { return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0); }
11137   bool Verify(flatbuffers::Verifier &verifier) const
11138   {
11139     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX) &&
11140            VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX) && verifier.EndTable();
11141   }
11142   IfOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11143   void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11144   static flatbuffers::Offset<IfOptions>
11145   Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o,
11146        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11147 };
11148
11149 struct IfOptionsBuilder
11150 {
11151   typedef IfOptions Table;
11152   flatbuffers::FlatBufferBuilder &fbb_;
11153   flatbuffers::uoffset_t start_;
11154   void add_then_subgraph_index(int32_t then_subgraph_index)
11155   {
11156     fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
11157   }
11158   void add_else_subgraph_index(int32_t else_subgraph_index)
11159   {
11160     fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
11161   }
11162   explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11163   {
11164     start_ = fbb_.StartTable();
11165   }
11166   flatbuffers::Offset<IfOptions> Finish()
11167   {
11168     const auto end = fbb_.EndTable(start_);
11169     auto o = flatbuffers::Offset<IfOptions>(end);
11170     return o;
11171   }
11172 };
11173
11174 inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb,
11175                                                       int32_t then_subgraph_index = 0,
11176                                                       int32_t else_subgraph_index = 0)
11177 {
11178   IfOptionsBuilder builder_(_fbb);
11179   builder_.add_else_subgraph_index(else_subgraph_index);
11180   builder_.add_then_subgraph_index(then_subgraph_index);
11181   return builder_.Finish();
11182 }
11183
11184 flatbuffers::Offset<IfOptions>
11185 CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o,
11186                 const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11187
11188 struct CallOnceOptionsT : public flatbuffers::NativeTable
11189 {
11190   typedef CallOnceOptions TableType;
11191   int32_t init_subgraph_index = 0;
11192 };
11193
11194 struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11195 {
11196   typedef CallOnceOptionsT NativeTableType;
11197   typedef CallOnceOptionsBuilder Builder;
11198   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11199   {
11200     VT_INIT_SUBGRAPH_INDEX = 4
11201   };
11202   int32_t init_subgraph_index() const { return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0); }
11203   bool Verify(flatbuffers::Verifier &verifier) const
11204   {
11205     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX) &&
11206            verifier.EndTable();
11207   }
11208   CallOnceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11209   void UnPackTo(CallOnceOptionsT *_o,
11210                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11211   static flatbuffers::Offset<CallOnceOptions>
11212   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o,
11213        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11214 };
11215
11216 struct CallOnceOptionsBuilder
11217 {
11218   typedef CallOnceOptions Table;
11219   flatbuffers::FlatBufferBuilder &fbb_;
11220   flatbuffers::uoffset_t start_;
11221   void add_init_subgraph_index(int32_t init_subgraph_index)
11222   {
11223     fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0);
11224   }
11225   explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11226   {
11227     start_ = fbb_.StartTable();
11228   }
11229   flatbuffers::Offset<CallOnceOptions> Finish()
11230   {
11231     const auto end = fbb_.EndTable(start_);
11232     auto o = flatbuffers::Offset<CallOnceOptions>(end);
11233     return o;
11234   }
11235 };
11236
11237 inline flatbuffers::Offset<CallOnceOptions>
11238 CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t init_subgraph_index = 0)
11239 {
11240   CallOnceOptionsBuilder builder_(_fbb);
11241   builder_.add_init_subgraph_index(init_subgraph_index);
11242   return builder_.Finish();
11243 }
11244
11245 flatbuffers::Offset<CallOnceOptions>
11246 CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o,
11247                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11248
11249 struct WhileOptionsT : public flatbuffers::NativeTable
11250 {
11251   typedef WhileOptions TableType;
11252   int32_t cond_subgraph_index = 0;
11253   int32_t body_subgraph_index = 0;
11254 };
11255
11256 struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11257 {
11258   typedef WhileOptionsT NativeTableType;
11259   typedef WhileOptionsBuilder Builder;
11260   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11261   {
11262     VT_COND_SUBGRAPH_INDEX = 4,
11263     VT_BODY_SUBGRAPH_INDEX = 6
11264   };
11265   int32_t cond_subgraph_index() const { return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0); }
11266   int32_t body_subgraph_index() const { return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0); }
11267   bool Verify(flatbuffers::Verifier &verifier) const
11268   {
11269     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX) &&
11270            VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX) && verifier.EndTable();
11271   }
11272   WhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11273   void UnPackTo(WhileOptionsT *_o,
11274                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11275   static flatbuffers::Offset<WhileOptions>
11276   Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o,
11277        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11278 };
11279
11280 struct WhileOptionsBuilder
11281 {
11282   typedef WhileOptions Table;
11283   flatbuffers::FlatBufferBuilder &fbb_;
11284   flatbuffers::uoffset_t start_;
11285   void add_cond_subgraph_index(int32_t cond_subgraph_index)
11286   {
11287     fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
11288   }
11289   void add_body_subgraph_index(int32_t body_subgraph_index)
11290   {
11291     fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
11292   }
11293   explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11294   {
11295     start_ = fbb_.StartTable();
11296   }
11297   flatbuffers::Offset<WhileOptions> Finish()
11298   {
11299     const auto end = fbb_.EndTable(start_);
11300     auto o = flatbuffers::Offset<WhileOptions>(end);
11301     return o;
11302   }
11303 };
11304
11305 inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb,
11306                                                             int32_t cond_subgraph_index = 0,
11307                                                             int32_t body_subgraph_index = 0)
11308 {
11309   WhileOptionsBuilder builder_(_fbb);
11310   builder_.add_body_subgraph_index(body_subgraph_index);
11311   builder_.add_cond_subgraph_index(cond_subgraph_index);
11312   return builder_.Finish();
11313 }
11314
11315 flatbuffers::Offset<WhileOptions>
11316 CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o,
11317                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11318
11319 struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable
11320 {
11321   typedef NonMaxSuppressionV4Options TableType;
11322 };
11323
11324 struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11325 {
11326   typedef NonMaxSuppressionV4OptionsT NativeTableType;
11327   typedef NonMaxSuppressionV4OptionsBuilder Builder;
11328   bool Verify(flatbuffers::Verifier &verifier) const
11329   {
11330     return VerifyTableStart(verifier) && verifier.EndTable();
11331   }
11332   NonMaxSuppressionV4OptionsT *
11333   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11334   void UnPackTo(NonMaxSuppressionV4OptionsT *_o,
11335                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11336   static flatbuffers::Offset<NonMaxSuppressionV4Options>
11337   Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o,
11338        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11339 };
11340
11341 struct NonMaxSuppressionV4OptionsBuilder
11342 {
11343   typedef NonMaxSuppressionV4Options Table;
11344   flatbuffers::FlatBufferBuilder &fbb_;
11345   flatbuffers::uoffset_t start_;
11346   explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11347   {
11348     start_ = fbb_.StartTable();
11349   }
11350   flatbuffers::Offset<NonMaxSuppressionV4Options> Finish()
11351   {
11352     const auto end = fbb_.EndTable(start_);
11353     auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
11354     return o;
11355   }
11356 };
11357
11358 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
11359 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb)
11360 {
11361   NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
11362   return builder_.Finish();
11363 }
11364
11365 flatbuffers::Offset<NonMaxSuppressionV4Options>
11366 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb,
11367                                  const NonMaxSuppressionV4OptionsT *_o,
11368                                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11369
11370 struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable
11371 {
11372   typedef NonMaxSuppressionV5Options TableType;
11373 };
11374
11375 struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11376 {
11377   typedef NonMaxSuppressionV5OptionsT NativeTableType;
11378   typedef NonMaxSuppressionV5OptionsBuilder Builder;
11379   bool Verify(flatbuffers::Verifier &verifier) const
11380   {
11381     return VerifyTableStart(verifier) && verifier.EndTable();
11382   }
11383   NonMaxSuppressionV5OptionsT *
11384   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11385   void UnPackTo(NonMaxSuppressionV5OptionsT *_o,
11386                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11387   static flatbuffers::Offset<NonMaxSuppressionV5Options>
11388   Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o,
11389        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11390 };
11391
11392 struct NonMaxSuppressionV5OptionsBuilder
11393 {
11394   typedef NonMaxSuppressionV5Options Table;
11395   flatbuffers::FlatBufferBuilder &fbb_;
11396   flatbuffers::uoffset_t start_;
11397   explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11398   {
11399     start_ = fbb_.StartTable();
11400   }
11401   flatbuffers::Offset<NonMaxSuppressionV5Options> Finish()
11402   {
11403     const auto end = fbb_.EndTable(start_);
11404     auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
11405     return o;
11406   }
11407 };
11408
11409 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
11410 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb)
11411 {
11412   NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
11413   return builder_.Finish();
11414 }
11415
11416 flatbuffers::Offset<NonMaxSuppressionV5Options>
11417 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb,
11418                                  const NonMaxSuppressionV5OptionsT *_o,
11419                                  const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11420
11421 struct ScatterNdOptionsT : public flatbuffers::NativeTable
11422 {
11423   typedef ScatterNdOptions TableType;
11424 };
11425
11426 struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11427 {
11428   typedef ScatterNdOptionsT NativeTableType;
11429   typedef ScatterNdOptionsBuilder Builder;
11430   bool Verify(flatbuffers::Verifier &verifier) const
11431   {
11432     return VerifyTableStart(verifier) && verifier.EndTable();
11433   }
11434   ScatterNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11435   void UnPackTo(ScatterNdOptionsT *_o,
11436                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11437   static flatbuffers::Offset<ScatterNdOptions>
11438   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o,
11439        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11440 };
11441
11442 struct ScatterNdOptionsBuilder
11443 {
11444   typedef ScatterNdOptions Table;
11445   flatbuffers::FlatBufferBuilder &fbb_;
11446   flatbuffers::uoffset_t start_;
11447   explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11448   {
11449     start_ = fbb_.StartTable();
11450   }
11451   flatbuffers::Offset<ScatterNdOptions> Finish()
11452   {
11453     const auto end = fbb_.EndTable(start_);
11454     auto o = flatbuffers::Offset<ScatterNdOptions>(end);
11455     return o;
11456   }
11457 };
11458
11459 inline flatbuffers::Offset<ScatterNdOptions>
11460 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
11461 {
11462   ScatterNdOptionsBuilder builder_(_fbb);
11463   return builder_.Finish();
11464 }
11465
11466 flatbuffers::Offset<ScatterNdOptions>
11467 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o,
11468                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11469
11470 struct SelectV2OptionsT : public flatbuffers::NativeTable
11471 {
11472   typedef SelectV2Options TableType;
11473 };
11474
11475 struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11476 {
11477   typedef SelectV2OptionsT NativeTableType;
11478   typedef SelectV2OptionsBuilder Builder;
11479   bool Verify(flatbuffers::Verifier &verifier) const
11480   {
11481     return VerifyTableStart(verifier) && verifier.EndTable();
11482   }
11483   SelectV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11484   void UnPackTo(SelectV2OptionsT *_o,
11485                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11486   static flatbuffers::Offset<SelectV2Options>
11487   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o,
11488        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11489 };
11490
11491 struct SelectV2OptionsBuilder
11492 {
11493   typedef SelectV2Options Table;
11494   flatbuffers::FlatBufferBuilder &fbb_;
11495   flatbuffers::uoffset_t start_;
11496   explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11497   {
11498     start_ = fbb_.StartTable();
11499   }
11500   flatbuffers::Offset<SelectV2Options> Finish()
11501   {
11502     const auto end = fbb_.EndTable(start_);
11503     auto o = flatbuffers::Offset<SelectV2Options>(end);
11504     return o;
11505   }
11506 };
11507
11508 inline flatbuffers::Offset<SelectV2Options>
11509 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb)
11510 {
11511   SelectV2OptionsBuilder builder_(_fbb);
11512   return builder_.Finish();
11513 }
11514
11515 flatbuffers::Offset<SelectV2Options>
11516 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o,
11517                       const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11518
11519 struct DensifyOptionsT : public flatbuffers::NativeTable
11520 {
11521   typedef DensifyOptions TableType;
11522 };
11523
11524 struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11525 {
11526   typedef DensifyOptionsT NativeTableType;
11527   typedef DensifyOptionsBuilder Builder;
11528   bool Verify(flatbuffers::Verifier &verifier) const
11529   {
11530     return VerifyTableStart(verifier) && verifier.EndTable();
11531   }
11532   DensifyOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11533   void UnPackTo(DensifyOptionsT *_o,
11534                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11535   static flatbuffers::Offset<DensifyOptions>
11536   Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o,
11537        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11538 };
11539
11540 struct DensifyOptionsBuilder
11541 {
11542   typedef DensifyOptions Table;
11543   flatbuffers::FlatBufferBuilder &fbb_;
11544   flatbuffers::uoffset_t start_;
11545   explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11546   {
11547     start_ = fbb_.StartTable();
11548   }
11549   flatbuffers::Offset<DensifyOptions> Finish()
11550   {
11551     const auto end = fbb_.EndTable(start_);
11552     auto o = flatbuffers::Offset<DensifyOptions>(end);
11553     return o;
11554   }
11555 };
11556
11557 inline flatbuffers::Offset<DensifyOptions>
11558 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb)
11559 {
11560   DensifyOptionsBuilder builder_(_fbb);
11561   return builder_.Finish();
11562 }
11563
11564 flatbuffers::Offset<DensifyOptions>
11565 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o,
11566                      const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11567
11568 struct SegmentSumOptionsT : public flatbuffers::NativeTable
11569 {
11570   typedef SegmentSumOptions TableType;
11571 };
11572
11573 struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11574 {
11575   typedef SegmentSumOptionsT NativeTableType;
11576   typedef SegmentSumOptionsBuilder Builder;
11577   bool Verify(flatbuffers::Verifier &verifier) const
11578   {
11579     return VerifyTableStart(verifier) && verifier.EndTable();
11580   }
11581   SegmentSumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11582   void UnPackTo(SegmentSumOptionsT *_o,
11583                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11584   static flatbuffers::Offset<SegmentSumOptions>
11585   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o,
11586        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11587 };
11588
11589 struct SegmentSumOptionsBuilder
11590 {
11591   typedef SegmentSumOptions Table;
11592   flatbuffers::FlatBufferBuilder &fbb_;
11593   flatbuffers::uoffset_t start_;
11594   explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11595   {
11596     start_ = fbb_.StartTable();
11597   }
11598   flatbuffers::Offset<SegmentSumOptions> Finish()
11599   {
11600     const auto end = fbb_.EndTable(start_);
11601     auto o = flatbuffers::Offset<SegmentSumOptions>(end);
11602     return o;
11603   }
11604 };
11605
11606 inline flatbuffers::Offset<SegmentSumOptions>
11607 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
11608 {
11609   SegmentSumOptionsBuilder builder_(_fbb);
11610   return builder_.Finish();
11611 }
11612
11613 flatbuffers::Offset<SegmentSumOptions>
11614 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o,
11615                         const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11616
11617 struct BatchMatMulOptionsT : public flatbuffers::NativeTable
11618 {
11619   typedef BatchMatMulOptions TableType;
11620   bool adjoint_lhs = false;
11621   bool adjoint_rhs = false;
11622   bool asymmetric_quantize_inputs = false;
11623 };
11624
11625 struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11626 {
11627   typedef BatchMatMulOptionsT NativeTableType;
11628   typedef BatchMatMulOptionsBuilder Builder;
11629   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11630   {
11631     VT_ADJOINT_LHS = 4,
11632     VT_ADJOINT_RHS = 6,
11633     VT_ASYMMETRIC_QUANTIZE_INPUTS = 8
11634   };
11635   bool adjoint_lhs() const { return GetField<uint8_t>(VT_ADJOINT_LHS, 0) != 0; }
11636   bool adjoint_rhs() const { return GetField<uint8_t>(VT_ADJOINT_RHS, 0) != 0; }
11637   bool asymmetric_quantize_inputs() const
11638   {
11639     return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
11640   }
11641   bool Verify(flatbuffers::Verifier &verifier) const
11642   {
11643     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_ADJOINT_LHS) &&
11644            VerifyField<uint8_t>(verifier, VT_ADJOINT_RHS) &&
11645            VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS) && verifier.EndTable();
11646   }
11647   BatchMatMulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11648   void UnPackTo(BatchMatMulOptionsT *_o,
11649                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11650   static flatbuffers::Offset<BatchMatMulOptions>
11651   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o,
11652        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11653 };
11654
11655 struct BatchMatMulOptionsBuilder
11656 {
11657   typedef BatchMatMulOptions Table;
11658   flatbuffers::FlatBufferBuilder &fbb_;
11659   flatbuffers::uoffset_t start_;
11660   void add_adjoint_lhs(bool adjoint_lhs)
11661   {
11662     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_LHS, static_cast<uint8_t>(adjoint_lhs),
11663                              0);
11664   }
11665   void add_adjoint_rhs(bool adjoint_rhs)
11666   {
11667     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJOINT_RHS, static_cast<uint8_t>(adjoint_rhs),
11668                              0);
11669   }
11670   void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
11671   {
11672     fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS,
11673                              static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
11674   }
11675   explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11676   {
11677     start_ = fbb_.StartTable();
11678   }
11679   flatbuffers::Offset<BatchMatMulOptions> Finish()
11680   {
11681     const auto end = fbb_.EndTable(start_);
11682     auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
11683     return o;
11684   }
11685 };
11686
11687 inline flatbuffers::Offset<BatchMatMulOptions>
11688 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, bool adjoint_lhs = false,
11689                          bool adjoint_rhs = false, bool asymmetric_quantize_inputs = false)
11690 {
11691   BatchMatMulOptionsBuilder builder_(_fbb);
11692   builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
11693   builder_.add_adjoint_rhs(adjoint_rhs);
11694   builder_.add_adjoint_lhs(adjoint_lhs);
11695   return builder_.Finish();
11696 }
11697
11698 flatbuffers::Offset<BatchMatMulOptions>
11699 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o,
11700                          const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11701
11702 struct CumsumOptionsT : public flatbuffers::NativeTable
11703 {
11704   typedef CumsumOptions TableType;
11705   bool exclusive = false;
11706   bool reverse = false;
11707 };
11708
11709 struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11710 {
11711   typedef CumsumOptionsT NativeTableType;
11712   typedef CumsumOptionsBuilder Builder;
11713   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11714   {
11715     VT_EXCLUSIVE = 4,
11716     VT_REVERSE = 6
11717   };
11718   bool exclusive() const { return GetField<uint8_t>(VT_EXCLUSIVE, 0) != 0; }
11719   bool reverse() const { return GetField<uint8_t>(VT_REVERSE, 0) != 0; }
11720   bool Verify(flatbuffers::Verifier &verifier) const
11721   {
11722     return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_EXCLUSIVE) &&
11723            VerifyField<uint8_t>(verifier, VT_REVERSE) && verifier.EndTable();
11724   }
11725   CumsumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11726   void UnPackTo(CumsumOptionsT *_o,
11727                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11728   static flatbuffers::Offset<CumsumOptions>
11729   Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o,
11730        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11731 };
11732
11733 struct CumsumOptionsBuilder
11734 {
11735   typedef CumsumOptions Table;
11736   flatbuffers::FlatBufferBuilder &fbb_;
11737   flatbuffers::uoffset_t start_;
11738   void add_exclusive(bool exclusive)
11739   {
11740     fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
11741   }
11742   void add_reverse(bool reverse)
11743   {
11744     fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
11745   }
11746   explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11747   {
11748     start_ = fbb_.StartTable();
11749   }
11750   flatbuffers::Offset<CumsumOptions> Finish()
11751   {
11752     const auto end = fbb_.EndTable(start_);
11753     auto o = flatbuffers::Offset<CumsumOptions>(end);
11754     return o;
11755   }
11756 };
11757
11758 inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb,
11759                                                               bool exclusive = false,
11760                                                               bool reverse = false)
11761 {
11762   CumsumOptionsBuilder builder_(_fbb);
11763   builder_.add_reverse(reverse);
11764   builder_.add_exclusive(exclusive);
11765   return builder_.Finish();
11766 }
11767
11768 flatbuffers::Offset<CumsumOptions>
11769 CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o,
11770                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11771
11772 struct BroadcastToOptionsT : public flatbuffers::NativeTable
11773 {
11774   typedef BroadcastToOptions TableType;
11775 };
11776
11777 struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11778 {
11779   typedef BroadcastToOptionsT NativeTableType;
11780   typedef BroadcastToOptionsBuilder Builder;
11781   bool Verify(flatbuffers::Verifier &verifier) const
11782   {
11783     return VerifyTableStart(verifier) && verifier.EndTable();
11784   }
11785   BroadcastToOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11786   void UnPackTo(BroadcastToOptionsT *_o,
11787                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11788   static flatbuffers::Offset<BroadcastToOptions>
11789   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o,
11790        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11791 };
11792
11793 struct BroadcastToOptionsBuilder
11794 {
11795   typedef BroadcastToOptions Table;
11796   flatbuffers::FlatBufferBuilder &fbb_;
11797   flatbuffers::uoffset_t start_;
11798   explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11799   {
11800     start_ = fbb_.StartTable();
11801   }
11802   flatbuffers::Offset<BroadcastToOptions> Finish()
11803   {
11804     const auto end = fbb_.EndTable(start_);
11805     auto o = flatbuffers::Offset<BroadcastToOptions>(end);
11806     return o;
11807   }
11808 };
11809
11810 inline flatbuffers::Offset<BroadcastToOptions>
11811 CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb)
11812 {
11813   BroadcastToOptionsBuilder builder_(_fbb);
11814   return builder_.Finish();
11815 }
11816
11817 flatbuffers::Offset<BroadcastToOptions>
11818 CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o,
11819                          const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11820
11821 struct Rfft2dOptionsT : public flatbuffers::NativeTable
11822 {
11823   typedef Rfft2dOptions TableType;
11824 };
11825
11826 struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11827 {
11828   typedef Rfft2dOptionsT NativeTableType;
11829   typedef Rfft2dOptionsBuilder Builder;
11830   bool Verify(flatbuffers::Verifier &verifier) const
11831   {
11832     return VerifyTableStart(verifier) && verifier.EndTable();
11833   }
11834   Rfft2dOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11835   void UnPackTo(Rfft2dOptionsT *_o,
11836                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11837   static flatbuffers::Offset<Rfft2dOptions>
11838   Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o,
11839        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11840 };
11841
11842 struct Rfft2dOptionsBuilder
11843 {
11844   typedef Rfft2dOptions Table;
11845   flatbuffers::FlatBufferBuilder &fbb_;
11846   flatbuffers::uoffset_t start_;
11847   explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11848   {
11849     start_ = fbb_.StartTable();
11850   }
11851   flatbuffers::Offset<Rfft2dOptions> Finish()
11852   {
11853     const auto end = fbb_.EndTable(start_);
11854     auto o = flatbuffers::Offset<Rfft2dOptions>(end);
11855     return o;
11856   }
11857 };
11858
11859 inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb)
11860 {
11861   Rfft2dOptionsBuilder builder_(_fbb);
11862   return builder_.Finish();
11863 }
11864
11865 flatbuffers::Offset<Rfft2dOptions>
11866 CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o,
11867                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11868
11869 struct HashtableOptionsT : public flatbuffers::NativeTable
11870 {
11871   typedef HashtableOptions TableType;
11872   int32_t table_id = 0;
11873   circle::TensorType key_dtype = circle::TensorType_FLOAT32;
11874   circle::TensorType value_dtype = circle::TensorType_FLOAT32;
11875 };
11876
11877 struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11878 {
11879   typedef HashtableOptionsT NativeTableType;
11880   typedef HashtableOptionsBuilder Builder;
11881   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
11882   {
11883     VT_TABLE_ID = 4,
11884     VT_KEY_DTYPE = 6,
11885     VT_VALUE_DTYPE = 8
11886   };
11887   int32_t table_id() const { return GetField<int32_t>(VT_TABLE_ID, 0); }
11888   circle::TensorType key_dtype() const
11889   {
11890     return static_cast<circle::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, 0));
11891   }
11892   circle::TensorType value_dtype() const
11893   {
11894     return static_cast<circle::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
11895   }
11896   bool Verify(flatbuffers::Verifier &verifier) const
11897   {
11898     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_TABLE_ID) &&
11899            VerifyField<int8_t>(verifier, VT_KEY_DTYPE) &&
11900            VerifyField<int8_t>(verifier, VT_VALUE_DTYPE) && verifier.EndTable();
11901   }
11902   HashtableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11903   void UnPackTo(HashtableOptionsT *_o,
11904                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11905   static flatbuffers::Offset<HashtableOptions>
11906   Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o,
11907        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11908 };
11909
11910 struct HashtableOptionsBuilder
11911 {
11912   typedef HashtableOptions Table;
11913   flatbuffers::FlatBufferBuilder &fbb_;
11914   flatbuffers::uoffset_t start_;
11915   void add_table_id(int32_t table_id)
11916   {
11917     fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
11918   }
11919   void add_key_dtype(circle::TensorType key_dtype)
11920   {
11921     fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), 0);
11922   }
11923   void add_value_dtype(circle::TensorType value_dtype)
11924   {
11925     fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
11926   }
11927   explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11928   {
11929     start_ = fbb_.StartTable();
11930   }
11931   flatbuffers::Offset<HashtableOptions> Finish()
11932   {
11933     const auto end = fbb_.EndTable(start_);
11934     auto o = flatbuffers::Offset<HashtableOptions>(end);
11935     return o;
11936   }
11937 };
11938
11939 inline flatbuffers::Offset<HashtableOptions>
11940 CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t table_id = 0,
11941                        circle::TensorType key_dtype = circle::TensorType_FLOAT32,
11942                        circle::TensorType value_dtype = circle::TensorType_FLOAT32)
11943 {
11944   HashtableOptionsBuilder builder_(_fbb);
11945   builder_.add_table_id(table_id);
11946   builder_.add_value_dtype(value_dtype);
11947   builder_.add_key_dtype(key_dtype);
11948   return builder_.Finish();
11949 }
11950
11951 flatbuffers::Offset<HashtableOptions>
11952 CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o,
11953                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11954
11955 struct HashtableFindOptionsT : public flatbuffers::NativeTable
11956 {
11957   typedef HashtableFindOptions TableType;
11958 };
11959
11960 struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
11961 {
11962   typedef HashtableFindOptionsT NativeTableType;
11963   typedef HashtableFindOptionsBuilder Builder;
11964   bool Verify(flatbuffers::Verifier &verifier) const
11965   {
11966     return VerifyTableStart(verifier) && verifier.EndTable();
11967   }
11968   HashtableFindOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11969   void UnPackTo(HashtableFindOptionsT *_o,
11970                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11971   static flatbuffers::Offset<HashtableFindOptions>
11972   Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o,
11973        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11974 };
11975
11976 struct HashtableFindOptionsBuilder
11977 {
11978   typedef HashtableFindOptions Table;
11979   flatbuffers::FlatBufferBuilder &fbb_;
11980   flatbuffers::uoffset_t start_;
11981   explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
11982   {
11983     start_ = fbb_.StartTable();
11984   }
11985   flatbuffers::Offset<HashtableFindOptions> Finish()
11986   {
11987     const auto end = fbb_.EndTable(start_);
11988     auto o = flatbuffers::Offset<HashtableFindOptions>(end);
11989     return o;
11990   }
11991 };
11992
11993 inline flatbuffers::Offset<HashtableFindOptions>
11994 CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb)
11995 {
11996   HashtableFindOptionsBuilder builder_(_fbb);
11997   return builder_.Finish();
11998 }
11999
12000 flatbuffers::Offset<HashtableFindOptions>
12001 CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o,
12002                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12003
12004 struct HashtableImportOptionsT : public flatbuffers::NativeTable
12005 {
12006   typedef HashtableImportOptions TableType;
12007 };
12008
12009 struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12010 {
12011   typedef HashtableImportOptionsT NativeTableType;
12012   typedef HashtableImportOptionsBuilder Builder;
12013   bool Verify(flatbuffers::Verifier &verifier) const
12014   {
12015     return VerifyTableStart(verifier) && verifier.EndTable();
12016   }
12017   HashtableImportOptionsT *
12018   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12019   void UnPackTo(HashtableImportOptionsT *_o,
12020                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12021   static flatbuffers::Offset<HashtableImportOptions>
12022   Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o,
12023        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12024 };
12025
12026 struct HashtableImportOptionsBuilder
12027 {
12028   typedef HashtableImportOptions Table;
12029   flatbuffers::FlatBufferBuilder &fbb_;
12030   flatbuffers::uoffset_t start_;
12031   explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12032   {
12033     start_ = fbb_.StartTable();
12034   }
12035   flatbuffers::Offset<HashtableImportOptions> Finish()
12036   {
12037     const auto end = fbb_.EndTable(start_);
12038     auto o = flatbuffers::Offset<HashtableImportOptions>(end);
12039     return o;
12040   }
12041 };
12042
12043 inline flatbuffers::Offset<HashtableImportOptions>
12044 CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb)
12045 {
12046   HashtableImportOptionsBuilder builder_(_fbb);
12047   return builder_.Finish();
12048 }
12049
12050 flatbuffers::Offset<HashtableImportOptions>
12051 CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb,
12052                              const HashtableImportOptionsT *_o,
12053                              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12054
12055 struct HashtableSizeOptionsT : public flatbuffers::NativeTable
12056 {
12057   typedef HashtableSizeOptions TableType;
12058 };
12059
12060 struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12061 {
12062   typedef HashtableSizeOptionsT NativeTableType;
12063   typedef HashtableSizeOptionsBuilder Builder;
12064   bool Verify(flatbuffers::Verifier &verifier) const
12065   {
12066     return VerifyTableStart(verifier) && verifier.EndTable();
12067   }
12068   HashtableSizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12069   void UnPackTo(HashtableSizeOptionsT *_o,
12070                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12071   static flatbuffers::Offset<HashtableSizeOptions>
12072   Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o,
12073        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12074 };
12075
12076 struct HashtableSizeOptionsBuilder
12077 {
12078   typedef HashtableSizeOptions Table;
12079   flatbuffers::FlatBufferBuilder &fbb_;
12080   flatbuffers::uoffset_t start_;
12081   explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12082   {
12083     start_ = fbb_.StartTable();
12084   }
12085   flatbuffers::Offset<HashtableSizeOptions> Finish()
12086   {
12087     const auto end = fbb_.EndTable(start_);
12088     auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
12089     return o;
12090   }
12091 };
12092
12093 inline flatbuffers::Offset<HashtableSizeOptions>
12094 CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
12095 {
12096   HashtableSizeOptionsBuilder builder_(_fbb);
12097   return builder_.Finish();
12098 }
12099
12100 flatbuffers::Offset<HashtableSizeOptions>
12101 CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o,
12102                            const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12103
12104 struct VarHandleOptionsT : public flatbuffers::NativeTable
12105 {
12106   typedef VarHandleOptions TableType;
12107   std::string container{};
12108   std::string shared_name{};
12109 };
12110
12111 struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12112 {
12113   typedef VarHandleOptionsT NativeTableType;
12114   typedef VarHandleOptionsBuilder Builder;
12115   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12116   {
12117     VT_CONTAINER = 4,
12118     VT_SHARED_NAME = 6
12119   };
12120   const flatbuffers::String *container() const
12121   {
12122     return GetPointer<const flatbuffers::String *>(VT_CONTAINER);
12123   }
12124   const flatbuffers::String *shared_name() const
12125   {
12126     return GetPointer<const flatbuffers::String *>(VT_SHARED_NAME);
12127   }
12128   bool Verify(flatbuffers::Verifier &verifier) const
12129   {
12130     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_CONTAINER) &&
12131            verifier.VerifyString(container()) && VerifyOffset(verifier, VT_SHARED_NAME) &&
12132            verifier.VerifyString(shared_name()) && verifier.EndTable();
12133   }
12134   VarHandleOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12135   void UnPackTo(VarHandleOptionsT *_o,
12136                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12137   static flatbuffers::Offset<VarHandleOptions>
12138   Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o,
12139        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12140 };
12141
12142 struct VarHandleOptionsBuilder
12143 {
12144   typedef VarHandleOptions Table;
12145   flatbuffers::FlatBufferBuilder &fbb_;
12146   flatbuffers::uoffset_t start_;
12147   void add_container(flatbuffers::Offset<flatbuffers::String> container)
12148   {
12149     fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container);
12150   }
12151   void add_shared_name(flatbuffers::Offset<flatbuffers::String> shared_name)
12152   {
12153     fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name);
12154   }
12155   explicit VarHandleOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12156   {
12157     start_ = fbb_.StartTable();
12158   }
12159   flatbuffers::Offset<VarHandleOptions> Finish()
12160   {
12161     const auto end = fbb_.EndTable(start_);
12162     auto o = flatbuffers::Offset<VarHandleOptions>(end);
12163     return o;
12164   }
12165 };
12166
12167 inline flatbuffers::Offset<VarHandleOptions>
12168 CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb,
12169                        flatbuffers::Offset<flatbuffers::String> container = 0,
12170                        flatbuffers::Offset<flatbuffers::String> shared_name = 0)
12171 {
12172   VarHandleOptionsBuilder builder_(_fbb);
12173   builder_.add_shared_name(shared_name);
12174   builder_.add_container(container);
12175   return builder_.Finish();
12176 }
12177
12178 inline flatbuffers::Offset<VarHandleOptions>
12179 CreateVarHandleOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *container = nullptr,
12180                              const char *shared_name = nullptr)
12181 {
12182   auto container__ = container ? _fbb.CreateString(container) : 0;
12183   auto shared_name__ = shared_name ? _fbb.CreateString(shared_name) : 0;
12184   return circle::CreateVarHandleOptions(_fbb, container__, shared_name__);
12185 }
12186
12187 flatbuffers::Offset<VarHandleOptions>
12188 CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o,
12189                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12190
12191 struct ReadVariableOptionsT : public flatbuffers::NativeTable
12192 {
12193   typedef ReadVariableOptions TableType;
12194 };
12195
12196 struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12197 {
12198   typedef ReadVariableOptionsT NativeTableType;
12199   typedef ReadVariableOptionsBuilder Builder;
12200   bool Verify(flatbuffers::Verifier &verifier) const
12201   {
12202     return VerifyTableStart(verifier) && verifier.EndTable();
12203   }
12204   ReadVariableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12205   void UnPackTo(ReadVariableOptionsT *_o,
12206                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12207   static flatbuffers::Offset<ReadVariableOptions>
12208   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o,
12209        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12210 };
12211
12212 struct ReadVariableOptionsBuilder
12213 {
12214   typedef ReadVariableOptions Table;
12215   flatbuffers::FlatBufferBuilder &fbb_;
12216   flatbuffers::uoffset_t start_;
12217   explicit ReadVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12218   {
12219     start_ = fbb_.StartTable();
12220   }
12221   flatbuffers::Offset<ReadVariableOptions> Finish()
12222   {
12223     const auto end = fbb_.EndTable(start_);
12224     auto o = flatbuffers::Offset<ReadVariableOptions>(end);
12225     return o;
12226   }
12227 };
12228
12229 inline flatbuffers::Offset<ReadVariableOptions>
12230 CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
12231 {
12232   ReadVariableOptionsBuilder builder_(_fbb);
12233   return builder_.Finish();
12234 }
12235
12236 flatbuffers::Offset<ReadVariableOptions>
12237 CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o,
12238                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12239
12240 struct AssignVariableOptionsT : public flatbuffers::NativeTable
12241 {
12242   typedef AssignVariableOptions TableType;
12243 };
12244
12245 struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12246 {
12247   typedef AssignVariableOptionsT NativeTableType;
12248   typedef AssignVariableOptionsBuilder Builder;
12249   bool Verify(flatbuffers::Verifier &verifier) const
12250   {
12251     return VerifyTableStart(verifier) && verifier.EndTable();
12252   }
12253   AssignVariableOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12254   void UnPackTo(AssignVariableOptionsT *_o,
12255                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12256   static flatbuffers::Offset<AssignVariableOptions>
12257   Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o,
12258        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12259 };
12260
12261 struct AssignVariableOptionsBuilder
12262 {
12263   typedef AssignVariableOptions Table;
12264   flatbuffers::FlatBufferBuilder &fbb_;
12265   flatbuffers::uoffset_t start_;
12266   explicit AssignVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12267   {
12268     start_ = fbb_.StartTable();
12269   }
12270   flatbuffers::Offset<AssignVariableOptions> Finish()
12271   {
12272     const auto end = fbb_.EndTable(start_);
12273     auto o = flatbuffers::Offset<AssignVariableOptions>(end);
12274     return o;
12275   }
12276 };
12277
12278 inline flatbuffers::Offset<AssignVariableOptions>
12279 CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
12280 {
12281   AssignVariableOptionsBuilder builder_(_fbb);
12282   return builder_.Finish();
12283 }
12284
12285 flatbuffers::Offset<AssignVariableOptions>
12286 CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o,
12287                             const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12288
12289 struct RandomOptionsT : public flatbuffers::NativeTable
12290 {
12291   typedef RandomOptions TableType;
12292   int32_t seed = 0;
12293   int32_t seed2 = 0;
12294 };
12295
12296 struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12297 {
12298   typedef RandomOptionsT NativeTableType;
12299   typedef RandomOptionsBuilder Builder;
12300   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12301   {
12302     VT_SEED = 4,
12303     VT_SEED2 = 6
12304   };
12305   int32_t seed() const { return GetField<int32_t>(VT_SEED, 0); }
12306   int32_t seed2() const { return GetField<int32_t>(VT_SEED2, 0); }
12307   bool Verify(flatbuffers::Verifier &verifier) const
12308   {
12309     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_SEED) &&
12310            VerifyField<int32_t>(verifier, VT_SEED2) && verifier.EndTable();
12311   }
12312   RandomOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12313   void UnPackTo(RandomOptionsT *_o,
12314                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12315   static flatbuffers::Offset<RandomOptions>
12316   Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o,
12317        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12318 };
12319
12320 struct RandomOptionsBuilder
12321 {
12322   typedef RandomOptions Table;
12323   flatbuffers::FlatBufferBuilder &fbb_;
12324   flatbuffers::uoffset_t start_;
12325   void add_seed(int32_t seed) { fbb_.AddElement<int32_t>(RandomOptions::VT_SEED, seed, 0); }
12326   void add_seed2(int32_t seed2) { fbb_.AddElement<int32_t>(RandomOptions::VT_SEED2, seed2, 0); }
12327   explicit RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12328   {
12329     start_ = fbb_.StartTable();
12330   }
12331   flatbuffers::Offset<RandomOptions> Finish()
12332   {
12333     const auto end = fbb_.EndTable(start_);
12334     auto o = flatbuffers::Offset<RandomOptions>(end);
12335     return o;
12336   }
12337 };
12338
12339 inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb,
12340                                                               int32_t seed = 0, int32_t seed2 = 0)
12341 {
12342   RandomOptionsBuilder builder_(_fbb);
12343   builder_.add_seed2(seed2);
12344   builder_.add_seed(seed);
12345   return builder_.Finish();
12346 }
12347
12348 flatbuffers::Offset<RandomOptions>
12349 CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o,
12350                     const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12351
12352 struct BCQGatherOptionsT : public flatbuffers::NativeTable
12353 {
12354   typedef BCQGatherOptions TableType;
12355   int32_t input_hidden_size = 0;
12356   int32_t axis = 0;
12357 };
12358
12359 struct BCQGatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12360 {
12361   typedef BCQGatherOptionsT NativeTableType;
12362   typedef BCQGatherOptionsBuilder Builder;
12363   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12364   {
12365     VT_INPUT_HIDDEN_SIZE = 4,
12366     VT_AXIS = 6
12367   };
12368   int32_t input_hidden_size() const { return GetField<int32_t>(VT_INPUT_HIDDEN_SIZE, 0); }
12369   int32_t axis() const { return GetField<int32_t>(VT_AXIS, 0); }
12370   bool Verify(flatbuffers::Verifier &verifier) const
12371   {
12372     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_INPUT_HIDDEN_SIZE) &&
12373            VerifyField<int32_t>(verifier, VT_AXIS) && verifier.EndTable();
12374   }
12375   BCQGatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12376   void UnPackTo(BCQGatherOptionsT *_o,
12377                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12378   static flatbuffers::Offset<BCQGatherOptions>
12379   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BCQGatherOptionsT *_o,
12380        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12381 };
12382
12383 struct BCQGatherOptionsBuilder
12384 {
12385   typedef BCQGatherOptions Table;
12386   flatbuffers::FlatBufferBuilder &fbb_;
12387   flatbuffers::uoffset_t start_;
12388   void add_input_hidden_size(int32_t input_hidden_size)
12389   {
12390     fbb_.AddElement<int32_t>(BCQGatherOptions::VT_INPUT_HIDDEN_SIZE, input_hidden_size, 0);
12391   }
12392   void add_axis(int32_t axis) { fbb_.AddElement<int32_t>(BCQGatherOptions::VT_AXIS, axis, 0); }
12393   explicit BCQGatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12394   {
12395     start_ = fbb_.StartTable();
12396   }
12397   flatbuffers::Offset<BCQGatherOptions> Finish()
12398   {
12399     const auto end = fbb_.EndTable(start_);
12400     auto o = flatbuffers::Offset<BCQGatherOptions>(end);
12401     return o;
12402   }
12403 };
12404
12405 inline flatbuffers::Offset<BCQGatherOptions>
12406 CreateBCQGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t input_hidden_size = 0,
12407                        int32_t axis = 0)
12408 {
12409   BCQGatherOptionsBuilder builder_(_fbb);
12410   builder_.add_axis(axis);
12411   builder_.add_input_hidden_size(input_hidden_size);
12412   return builder_.Finish();
12413 }
12414
12415 flatbuffers::Offset<BCQGatherOptions>
12416 CreateBCQGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const BCQGatherOptionsT *_o,
12417                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12418
12419 struct BCQFullyConnectedOptionsT : public flatbuffers::NativeTable
12420 {
12421   typedef BCQFullyConnectedOptions TableType;
12422   int32_t weights_hidden_size = 0;
12423   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
12424 };
12425
12426 struct BCQFullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12427 {
12428   typedef BCQFullyConnectedOptionsT NativeTableType;
12429   typedef BCQFullyConnectedOptionsBuilder Builder;
12430   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12431   {
12432     VT_WEIGHTS_HIDDEN_SIZE = 4,
12433     VT_FUSED_ACTIVATION_FUNCTION = 6
12434   };
12435   int32_t weights_hidden_size() const { return GetField<int32_t>(VT_WEIGHTS_HIDDEN_SIZE, 0); }
12436   circle::ActivationFunctionType fused_activation_function() const
12437   {
12438     return static_cast<circle::ActivationFunctionType>(
12439       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
12440   }
12441   bool Verify(flatbuffers::Verifier &verifier) const
12442   {
12443     return VerifyTableStart(verifier) && VerifyField<int32_t>(verifier, VT_WEIGHTS_HIDDEN_SIZE) &&
12444            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
12445   }
12446   BCQFullyConnectedOptionsT *
12447   UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12448   void UnPackTo(BCQFullyConnectedOptionsT *_o,
12449                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12450   static flatbuffers::Offset<BCQFullyConnectedOptions>
12451   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BCQFullyConnectedOptionsT *_o,
12452        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12453 };
12454
12455 struct BCQFullyConnectedOptionsBuilder
12456 {
12457   typedef BCQFullyConnectedOptions Table;
12458   flatbuffers::FlatBufferBuilder &fbb_;
12459   flatbuffers::uoffset_t start_;
12460   void add_weights_hidden_size(int32_t weights_hidden_size)
12461   {
12462     fbb_.AddElement<int32_t>(BCQFullyConnectedOptions::VT_WEIGHTS_HIDDEN_SIZE, weights_hidden_size,
12463                              0);
12464   }
12465   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
12466   {
12467     fbb_.AddElement<int8_t>(BCQFullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION,
12468                             static_cast<int8_t>(fused_activation_function), 0);
12469   }
12470   explicit BCQFullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12471   {
12472     start_ = fbb_.StartTable();
12473   }
12474   flatbuffers::Offset<BCQFullyConnectedOptions> Finish()
12475   {
12476     const auto end = fbb_.EndTable(start_);
12477     auto o = flatbuffers::Offset<BCQFullyConnectedOptions>(end);
12478     return o;
12479   }
12480 };
12481
12482 inline flatbuffers::Offset<BCQFullyConnectedOptions> CreateBCQFullyConnectedOptions(
12483   flatbuffers::FlatBufferBuilder &_fbb, int32_t weights_hidden_size = 0,
12484   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
12485 {
12486   BCQFullyConnectedOptionsBuilder builder_(_fbb);
12487   builder_.add_weights_hidden_size(weights_hidden_size);
12488   builder_.add_fused_activation_function(fused_activation_function);
12489   return builder_.Finish();
12490 }
12491
12492 flatbuffers::Offset<BCQFullyConnectedOptions>
12493 CreateBCQFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb,
12494                                const BCQFullyConnectedOptionsT *_o,
12495                                const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12496
12497 struct InstanceNormOptionsT : public flatbuffers::NativeTable
12498 {
12499   typedef InstanceNormOptions TableType;
12500   float epsilon = 0.0f;
12501   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE;
12502 };
12503
12504 struct InstanceNormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12505 {
12506   typedef InstanceNormOptionsT NativeTableType;
12507   typedef InstanceNormOptionsBuilder Builder;
12508   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12509   {
12510     VT_EPSILON = 4,
12511     VT_FUSED_ACTIVATION_FUNCTION = 6
12512   };
12513   float epsilon() const { return GetField<float>(VT_EPSILON, 0.0f); }
12514   circle::ActivationFunctionType fused_activation_function() const
12515   {
12516     return static_cast<circle::ActivationFunctionType>(
12517       GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
12518   }
12519   bool Verify(flatbuffers::Verifier &verifier) const
12520   {
12521     return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_EPSILON) &&
12522            VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
12523   }
12524   InstanceNormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12525   void UnPackTo(InstanceNormOptionsT *_o,
12526                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12527   static flatbuffers::Offset<InstanceNormOptions>
12528   Pack(flatbuffers::FlatBufferBuilder &_fbb, const InstanceNormOptionsT *_o,
12529        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12530 };
12531
12532 struct InstanceNormOptionsBuilder
12533 {
12534   typedef InstanceNormOptions Table;
12535   flatbuffers::FlatBufferBuilder &fbb_;
12536   flatbuffers::uoffset_t start_;
12537   void add_epsilon(float epsilon)
12538   {
12539     fbb_.AddElement<float>(InstanceNormOptions::VT_EPSILON, epsilon, 0.0f);
12540   }
12541   void add_fused_activation_function(circle::ActivationFunctionType fused_activation_function)
12542   {
12543     fbb_.AddElement<int8_t>(InstanceNormOptions::VT_FUSED_ACTIVATION_FUNCTION,
12544                             static_cast<int8_t>(fused_activation_function), 0);
12545   }
12546   explicit InstanceNormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12547   {
12548     start_ = fbb_.StartTable();
12549   }
12550   flatbuffers::Offset<InstanceNormOptions> Finish()
12551   {
12552     const auto end = fbb_.EndTable(start_);
12553     auto o = flatbuffers::Offset<InstanceNormOptions>(end);
12554     return o;
12555   }
12556 };
12557
12558 inline flatbuffers::Offset<InstanceNormOptions> CreateInstanceNormOptions(
12559   flatbuffers::FlatBufferBuilder &_fbb, float epsilon = 0.0f,
12560   circle::ActivationFunctionType fused_activation_function = circle::ActivationFunctionType_NONE)
12561 {
12562   InstanceNormOptionsBuilder builder_(_fbb);
12563   builder_.add_epsilon(epsilon);
12564   builder_.add_fused_activation_function(fused_activation_function);
12565   return builder_.Finish();
12566 }
12567
12568 flatbuffers::Offset<InstanceNormOptions>
12569 CreateInstanceNormOptions(flatbuffers::FlatBufferBuilder &_fbb, const InstanceNormOptionsT *_o,
12570                           const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12571
12572 struct OperatorCodeT : public flatbuffers::NativeTable
12573 {
12574   typedef OperatorCode TableType;
12575   int8_t deprecated_builtin_code = 0;
12576   std::string custom_code{};
12577   int32_t version = 1;
12578   circle::BuiltinOperator builtin_code = circle::BuiltinOperator_ADD;
12579 };
12580
12581 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12582 {
12583   typedef OperatorCodeT NativeTableType;
12584   typedef OperatorCodeBuilder Builder;
12585   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12586   {
12587     VT_DEPRECATED_BUILTIN_CODE = 4,
12588     VT_CUSTOM_CODE = 6,
12589     VT_VERSION = 8,
12590     VT_BUILTIN_CODE = 10
12591   };
12592   int8_t deprecated_builtin_code() const { return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0); }
12593   const flatbuffers::String *custom_code() const
12594   {
12595     return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
12596   }
12597   int32_t version() const { return GetField<int32_t>(VT_VERSION, 1); }
12598   circle::BuiltinOperator builtin_code() const
12599   {
12600     return static_cast<circle::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
12601   }
12602   bool Verify(flatbuffers::Verifier &verifier) const
12603   {
12604     return VerifyTableStart(verifier) &&
12605            VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE) &&
12606            VerifyOffset(verifier, VT_CUSTOM_CODE) && verifier.VerifyString(custom_code()) &&
12607            VerifyField<int32_t>(verifier, VT_VERSION) &&
12608            VerifyField<int32_t>(verifier, VT_BUILTIN_CODE) && verifier.EndTable();
12609   }
12610   OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12611   void UnPackTo(OperatorCodeT *_o,
12612                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12613   static flatbuffers::Offset<OperatorCode>
12614   Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o,
12615        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12616 };
12617
12618 struct OperatorCodeBuilder
12619 {
12620   typedef OperatorCode Table;
12621   flatbuffers::FlatBufferBuilder &fbb_;
12622   flatbuffers::uoffset_t start_;
12623   void add_deprecated_builtin_code(int8_t deprecated_builtin_code)
12624   {
12625     fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
12626   }
12627   void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code)
12628   {
12629     fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
12630   }
12631   void add_version(int32_t version)
12632   {
12633     fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
12634   }
12635   void add_builtin_code(circle::BuiltinOperator builtin_code)
12636   {
12637     fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
12638   }
12639   explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
12640   {
12641     start_ = fbb_.StartTable();
12642   }
12643   flatbuffers::Offset<OperatorCode> Finish()
12644   {
12645     const auto end = fbb_.EndTable(start_);
12646     auto o = flatbuffers::Offset<OperatorCode>(end);
12647     return o;
12648   }
12649 };
12650
12651 inline flatbuffers::Offset<OperatorCode>
12652 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0,
12653                    flatbuffers::Offset<flatbuffers::String> custom_code = 0, int32_t version = 1,
12654                    circle::BuiltinOperator builtin_code = circle::BuiltinOperator_ADD)
12655 {
12656   OperatorCodeBuilder builder_(_fbb);
12657   builder_.add_builtin_code(builtin_code);
12658   builder_.add_version(version);
12659   builder_.add_custom_code(custom_code);
12660   builder_.add_deprecated_builtin_code(deprecated_builtin_code);
12661   return builder_.Finish();
12662 }
12663
12664 inline flatbuffers::Offset<OperatorCode>
12665 CreateOperatorCodeDirect(flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code = 0,
12666                          const char *custom_code = nullptr, int32_t version = 1,
12667                          circle::BuiltinOperator builtin_code = circle::BuiltinOperator_ADD)
12668 {
12669   auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
12670   return circle::CreateOperatorCode(_fbb, deprecated_builtin_code, custom_code__, version,
12671                                     builtin_code);
12672 }
12673
12674 flatbuffers::Offset<OperatorCode>
12675 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o,
12676                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12677
12678 struct OperatorT : public flatbuffers::NativeTable
12679 {
12680   typedef Operator TableType;
12681   uint32_t opcode_index = 0;
12682   std::vector<int32_t> inputs{};
12683   std::vector<int32_t> outputs{};
12684   circle::BuiltinOptionsUnion builtin_options{};
12685   std::vector<uint8_t> custom_options{};
12686   circle::CustomOptionsFormat custom_options_format = circle::CustomOptionsFormat_FLEXBUFFERS;
12687   std::vector<bool> mutating_variable_inputs{};
12688   std::vector<int32_t> intermediates{};
12689 };
12690
12691 struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
12692 {
12693   typedef OperatorT NativeTableType;
12694   typedef OperatorBuilder Builder;
12695   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
12696   {
12697     VT_OPCODE_INDEX = 4,
12698     VT_INPUTS = 6,
12699     VT_OUTPUTS = 8,
12700     VT_BUILTIN_OPTIONS_TYPE = 10,
12701     VT_BUILTIN_OPTIONS = 12,
12702     VT_CUSTOM_OPTIONS = 14,
12703     VT_CUSTOM_OPTIONS_FORMAT = 16,
12704     VT_MUTATING_VARIABLE_INPUTS = 18,
12705     VT_INTERMEDIATES = 20
12706   };
12707   uint32_t opcode_index() const { return GetField<uint32_t>(VT_OPCODE_INDEX, 0); }
12708   const flatbuffers::Vector<int32_t> *inputs() const
12709   {
12710     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
12711   }
12712   const flatbuffers::Vector<int32_t> *outputs() const
12713   {
12714     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
12715   }
12716   circle::BuiltinOptions builtin_options_type() const
12717   {
12718     return static_cast<circle::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
12719   }
12720   const void *builtin_options() const { return GetPointer<const void *>(VT_BUILTIN_OPTIONS); }
12721   template <typename T> const T *builtin_options_as() const;
12722   const circle::Conv2DOptions *builtin_options_as_Conv2DOptions() const
12723   {
12724     return builtin_options_type() == circle::BuiltinOptions_Conv2DOptions
12725              ? static_cast<const circle::Conv2DOptions *>(builtin_options())
12726              : nullptr;
12727   }
12728   const circle::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const
12729   {
12730     return builtin_options_type() == circle::BuiltinOptions_DepthwiseConv2DOptions
12731              ? static_cast<const circle::DepthwiseConv2DOptions *>(builtin_options())
12732              : nullptr;
12733   }
12734   const circle::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const
12735   {
12736     return builtin_options_type() == circle::BuiltinOptions_ConcatEmbeddingsOptions
12737              ? static_cast<const circle::ConcatEmbeddingsOptions *>(builtin_options())
12738              : nullptr;
12739   }
12740   const circle::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const
12741   {
12742     return builtin_options_type() == circle::BuiltinOptions_LSHProjectionOptions
12743              ? static_cast<const circle::LSHProjectionOptions *>(builtin_options())
12744              : nullptr;
12745   }
12746   const circle::Pool2DOptions *builtin_options_as_Pool2DOptions() const
12747   {
12748     return builtin_options_type() == circle::BuiltinOptions_Pool2DOptions
12749              ? static_cast<const circle::Pool2DOptions *>(builtin_options())
12750              : nullptr;
12751   }
12752   const circle::SVDFOptions *builtin_options_as_SVDFOptions() const
12753   {
12754     return builtin_options_type() == circle::BuiltinOptions_SVDFOptions
12755              ? static_cast<const circle::SVDFOptions *>(builtin_options())
12756              : nullptr;
12757   }
12758   const circle::RNNOptions *builtin_options_as_RNNOptions() const
12759   {
12760     return builtin_options_type() == circle::BuiltinOptions_RNNOptions
12761              ? static_cast<const circle::RNNOptions *>(builtin_options())
12762              : nullptr;
12763   }
12764   const circle::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const
12765   {
12766     return builtin_options_type() == circle::BuiltinOptions_FullyConnectedOptions
12767              ? static_cast<const circle::FullyConnectedOptions *>(builtin_options())
12768              : nullptr;
12769   }
12770   const circle::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const
12771   {
12772     return builtin_options_type() == circle::BuiltinOptions_SoftmaxOptions
12773              ? static_cast<const circle::SoftmaxOptions *>(builtin_options())
12774              : nullptr;
12775   }
12776   const circle::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const
12777   {
12778     return builtin_options_type() == circle::BuiltinOptions_ConcatenationOptions
12779              ? static_cast<const circle::ConcatenationOptions *>(builtin_options())
12780              : nullptr;
12781   }
12782   const circle::AddOptions *builtin_options_as_AddOptions() const
12783   {
12784     return builtin_options_type() == circle::BuiltinOptions_AddOptions
12785              ? static_cast<const circle::AddOptions *>(builtin_options())
12786              : nullptr;
12787   }
12788   const circle::L2NormOptions *builtin_options_as_L2NormOptions() const
12789   {
12790     return builtin_options_type() == circle::BuiltinOptions_L2NormOptions
12791              ? static_cast<const circle::L2NormOptions *>(builtin_options())
12792              : nullptr;
12793   }
12794   const circle::LocalResponseNormalizationOptions *
12795   builtin_options_as_LocalResponseNormalizationOptions() const
12796   {
12797     return builtin_options_type() == circle::BuiltinOptions_LocalResponseNormalizationOptions
12798              ? static_cast<const circle::LocalResponseNormalizationOptions *>(builtin_options())
12799              : nullptr;
12800   }
12801   const circle::LSTMOptions *builtin_options_as_LSTMOptions() const
12802   {
12803     return builtin_options_type() == circle::BuiltinOptions_LSTMOptions
12804              ? static_cast<const circle::LSTMOptions *>(builtin_options())
12805              : nullptr;
12806   }
12807   const circle::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const
12808   {
12809     return builtin_options_type() == circle::BuiltinOptions_ResizeBilinearOptions
12810              ? static_cast<const circle::ResizeBilinearOptions *>(builtin_options())
12811              : nullptr;
12812   }
12813   const circle::CallOptions *builtin_options_as_CallOptions() const
12814   {
12815     return builtin_options_type() == circle::BuiltinOptions_CallOptions
12816              ? static_cast<const circle::CallOptions *>(builtin_options())
12817              : nullptr;
12818   }
12819   const circle::ReshapeOptions *builtin_options_as_ReshapeOptions() const
12820   {
12821     return builtin_options_type() == circle::BuiltinOptions_ReshapeOptions
12822              ? static_cast<const circle::ReshapeOptions *>(builtin_options())
12823              : nullptr;
12824   }
12825   const circle::SkipGramOptions *builtin_options_as_SkipGramOptions() const
12826   {
12827     return builtin_options_type() == circle::BuiltinOptions_SkipGramOptions
12828              ? static_cast<const circle::SkipGramOptions *>(builtin_options())
12829              : nullptr;
12830   }
12831   const circle::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const
12832   {
12833     return builtin_options_type() == circle::BuiltinOptions_SpaceToDepthOptions
12834              ? static_cast<const circle::SpaceToDepthOptions *>(builtin_options())
12835              : nullptr;
12836   }
12837   const circle::EmbeddingLookupSparseOptions *
12838   builtin_options_as_EmbeddingLookupSparseOptions() const
12839   {
12840     return builtin_options_type() == circle::BuiltinOptions_EmbeddingLookupSparseOptions
12841              ? static_cast<const circle::EmbeddingLookupSparseOptions *>(builtin_options())
12842              : nullptr;
12843   }
12844   const circle::MulOptions *builtin_options_as_MulOptions() const
12845   {
12846     return builtin_options_type() == circle::BuiltinOptions_MulOptions
12847              ? static_cast<const circle::MulOptions *>(builtin_options())
12848              : nullptr;
12849   }
12850   const circle::PadOptions *builtin_options_as_PadOptions() const
12851   {
12852     return builtin_options_type() == circle::BuiltinOptions_PadOptions
12853              ? static_cast<const circle::PadOptions *>(builtin_options())
12854              : nullptr;
12855   }
12856   const circle::GatherOptions *builtin_options_as_GatherOptions() const
12857   {
12858     return builtin_options_type() == circle::BuiltinOptions_GatherOptions
12859              ? static_cast<const circle::GatherOptions *>(builtin_options())
12860              : nullptr;
12861   }
12862   const circle::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const
12863   {
12864     return builtin_options_type() == circle::BuiltinOptions_BatchToSpaceNDOptions
12865              ? static_cast<const circle::BatchToSpaceNDOptions *>(builtin_options())
12866              : nullptr;
12867   }
12868   const circle::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const
12869   {
12870     return builtin_options_type() == circle::BuiltinOptions_SpaceToBatchNDOptions
12871              ? static_cast<const circle::SpaceToBatchNDOptions *>(builtin_options())
12872              : nullptr;
12873   }
12874   const circle::TransposeOptions *builtin_options_as_TransposeOptions() const
12875   {
12876     return builtin_options_type() == circle::BuiltinOptions_TransposeOptions
12877              ? static_cast<const circle::TransposeOptions *>(builtin_options())
12878              : nullptr;
12879   }
12880   const circle::ReducerOptions *builtin_options_as_ReducerOptions() const
12881   {
12882     return builtin_options_type() == circle::BuiltinOptions_ReducerOptions
12883              ? static_cast<const circle::ReducerOptions *>(builtin_options())
12884              : nullptr;
12885   }
12886   const circle::SubOptions *builtin_options_as_SubOptions() const
12887   {
12888     return builtin_options_type() == circle::BuiltinOptions_SubOptions
12889              ? static_cast<const circle::SubOptions *>(builtin_options())
12890              : nullptr;
12891   }
12892   const circle::DivOptions *builtin_options_as_DivOptions() const
12893   {
12894     return builtin_options_type() == circle::BuiltinOptions_DivOptions
12895              ? static_cast<const circle::DivOptions *>(builtin_options())
12896              : nullptr;
12897   }
12898   const circle::SqueezeOptions *builtin_options_as_SqueezeOptions() const
12899   {
12900     return builtin_options_type() == circle::BuiltinOptions_SqueezeOptions
12901              ? static_cast<const circle::SqueezeOptions *>(builtin_options())
12902              : nullptr;
12903   }
12904   const circle::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const
12905   {
12906     return builtin_options_type() == circle::BuiltinOptions_SequenceRNNOptions
12907              ? static_cast<const circle::SequenceRNNOptions *>(builtin_options())
12908              : nullptr;
12909   }
12910   const circle::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const
12911   {
12912     return builtin_options_type() == circle::BuiltinOptions_StridedSliceOptions
12913              ? static_cast<const circle::StridedSliceOptions *>(builtin_options())
12914              : nullptr;
12915   }
12916   const circle::ExpOptions *builtin_options_as_ExpOptions() const
12917   {
12918     return builtin_options_type() == circle::BuiltinOptions_ExpOptions
12919              ? static_cast<const circle::ExpOptions *>(builtin_options())
12920              : nullptr;
12921   }
12922   const circle::TopKV2Options *builtin_options_as_TopKV2Options() const
12923   {
12924     return builtin_options_type() == circle::BuiltinOptions_TopKV2Options
12925              ? static_cast<const circle::TopKV2Options *>(builtin_options())
12926              : nullptr;
12927   }
12928   const circle::SplitOptions *builtin_options_as_SplitOptions() const
12929   {
12930     return builtin_options_type() == circle::BuiltinOptions_SplitOptions
12931              ? static_cast<const circle::SplitOptions *>(builtin_options())
12932              : nullptr;
12933   }
12934   const circle::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const
12935   {
12936     return builtin_options_type() == circle::BuiltinOptions_LogSoftmaxOptions
12937              ? static_cast<const circle::LogSoftmaxOptions *>(builtin_options())
12938              : nullptr;
12939   }
12940   const circle::CastOptions *builtin_options_as_CastOptions() const
12941   {
12942     return builtin_options_type() == circle::BuiltinOptions_CastOptions
12943              ? static_cast<const circle::CastOptions *>(builtin_options())
12944              : nullptr;
12945   }
12946   const circle::DequantizeOptions *builtin_options_as_DequantizeOptions() const
12947   {
12948     return builtin_options_type() == circle::BuiltinOptions_DequantizeOptions
12949              ? static_cast<const circle::DequantizeOptions *>(builtin_options())
12950              : nullptr;
12951   }
12952   const circle::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const
12953   {
12954     return builtin_options_type() == circle::BuiltinOptions_MaximumMinimumOptions
12955              ? static_cast<const circle::MaximumMinimumOptions *>(builtin_options())
12956              : nullptr;
12957   }
12958   const circle::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const
12959   {
12960     return builtin_options_type() == circle::BuiltinOptions_ArgMaxOptions
12961              ? static_cast<const circle::ArgMaxOptions *>(builtin_options())
12962              : nullptr;
12963   }
12964   const circle::LessOptions *builtin_options_as_LessOptions() const
12965   {
12966     return builtin_options_type() == circle::BuiltinOptions_LessOptions
12967              ? static_cast<const circle::LessOptions *>(builtin_options())
12968              : nullptr;
12969   }
12970   const circle::NegOptions *builtin_options_as_NegOptions() const
12971   {
12972     return builtin_options_type() == circle::BuiltinOptions_NegOptions
12973              ? static_cast<const circle::NegOptions *>(builtin_options())
12974              : nullptr;
12975   }
12976   const circle::PadV2Options *builtin_options_as_PadV2Options() const
12977   {
12978     return builtin_options_type() == circle::BuiltinOptions_PadV2Options
12979              ? static_cast<const circle::PadV2Options *>(builtin_options())
12980              : nullptr;
12981   }
12982   const circle::GreaterOptions *builtin_options_as_GreaterOptions() const
12983   {
12984     return builtin_options_type() == circle::BuiltinOptions_GreaterOptions
12985              ? static_cast<const circle::GreaterOptions *>(builtin_options())
12986              : nullptr;
12987   }
12988   const circle::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const
12989   {
12990     return builtin_options_type() == circle::BuiltinOptions_GreaterEqualOptions
12991              ? static_cast<const circle::GreaterEqualOptions *>(builtin_options())
12992              : nullptr;
12993   }
12994   const circle::LessEqualOptions *builtin_options_as_LessEqualOptions() const
12995   {
12996     return builtin_options_type() == circle::BuiltinOptions_LessEqualOptions
12997              ? static_cast<const circle::LessEqualOptions *>(builtin_options())
12998              : nullptr;
12999   }
13000   const circle::SelectOptions *builtin_options_as_SelectOptions() const
13001   {
13002     return builtin_options_type() == circle::BuiltinOptions_SelectOptions
13003              ? static_cast<const circle::SelectOptions *>(builtin_options())
13004              : nullptr;
13005   }
13006   const circle::SliceOptions *builtin_options_as_SliceOptions() const
13007   {
13008     return builtin_options_type() == circle::BuiltinOptions_SliceOptions
13009              ? static_cast<const circle::SliceOptions *>(builtin_options())
13010              : nullptr;
13011   }
13012   const circle::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const
13013   {
13014     return builtin_options_type() == circle::BuiltinOptions_TransposeConvOptions
13015              ? static_cast<const circle::TransposeConvOptions *>(builtin_options())
13016              : nullptr;
13017   }
13018   const circle::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const
13019   {
13020     return builtin_options_type() == circle::BuiltinOptions_SparseToDenseOptions
13021              ? static_cast<const circle::SparseToDenseOptions *>(builtin_options())
13022              : nullptr;
13023   }
13024   const circle::TileOptions *builtin_options_as_TileOptions() const
13025   {
13026     return builtin_options_type() == circle::BuiltinOptions_TileOptions
13027              ? static_cast<const circle::TileOptions *>(builtin_options())
13028              : nullptr;
13029   }
13030   const circle::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const
13031   {
13032     return builtin_options_type() == circle::BuiltinOptions_ExpandDimsOptions
13033              ? static_cast<const circle::ExpandDimsOptions *>(builtin_options())
13034              : nullptr;
13035   }
13036   const circle::EqualOptions *builtin_options_as_EqualOptions() const
13037   {
13038     return builtin_options_type() == circle::BuiltinOptions_EqualOptions
13039              ? static_cast<const circle::EqualOptions *>(builtin_options())
13040              : nullptr;
13041   }
13042   const circle::NotEqualOptions *builtin_options_as_NotEqualOptions() const
13043   {
13044     return builtin_options_type() == circle::BuiltinOptions_NotEqualOptions
13045              ? static_cast<const circle::NotEqualOptions *>(builtin_options())
13046              : nullptr;
13047   }
13048   const circle::ShapeOptions *builtin_options_as_ShapeOptions() const
13049   {
13050     return builtin_options_type() == circle::BuiltinOptions_ShapeOptions
13051              ? static_cast<const circle::ShapeOptions *>(builtin_options())
13052              : nullptr;
13053   }
13054   const circle::PowOptions *builtin_options_as_PowOptions() const
13055   {
13056     return builtin_options_type() == circle::BuiltinOptions_PowOptions
13057              ? static_cast<const circle::PowOptions *>(builtin_options())
13058              : nullptr;
13059   }
13060   const circle::ArgMinOptions *builtin_options_as_ArgMinOptions() const
13061   {
13062     return builtin_options_type() == circle::BuiltinOptions_ArgMinOptions
13063              ? static_cast<const circle::ArgMinOptions *>(builtin_options())
13064              : nullptr;
13065   }
13066   const circle::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const
13067   {
13068     return builtin_options_type() == circle::BuiltinOptions_FakeQuantOptions
13069              ? static_cast<const circle::FakeQuantOptions *>(builtin_options())
13070              : nullptr;
13071   }
13072   const circle::PackOptions *builtin_options_as_PackOptions() const
13073   {
13074     return builtin_options_type() == circle::BuiltinOptions_PackOptions
13075              ? static_cast<const circle::PackOptions *>(builtin_options())
13076              : nullptr;
13077   }
13078   const circle::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const
13079   {
13080     return builtin_options_type() == circle::BuiltinOptions_LogicalOrOptions
13081              ? static_cast<const circle::LogicalOrOptions *>(builtin_options())
13082              : nullptr;
13083   }
13084   const circle::OneHotOptions *builtin_options_as_OneHotOptions() const
13085   {
13086     return builtin_options_type() == circle::BuiltinOptions_OneHotOptions
13087              ? static_cast<const circle::OneHotOptions *>(builtin_options())
13088              : nullptr;
13089   }
13090   const circle::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const
13091   {
13092     return builtin_options_type() == circle::BuiltinOptions_LogicalAndOptions
13093              ? static_cast<const circle::LogicalAndOptions *>(builtin_options())
13094              : nullptr;
13095   }
13096   const circle::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const
13097   {
13098     return builtin_options_type() == circle::BuiltinOptions_LogicalNotOptions
13099              ? static_cast<const circle::LogicalNotOptions *>(builtin_options())
13100              : nullptr;
13101   }
13102   const circle::UnpackOptions *builtin_options_as_UnpackOptions() const
13103   {
13104     return builtin_options_type() == circle::BuiltinOptions_UnpackOptions
13105              ? static_cast<const circle::UnpackOptions *>(builtin_options())
13106              : nullptr;
13107   }
13108   const circle::FloorDivOptions *builtin_options_as_FloorDivOptions() const
13109   {
13110     return builtin_options_type() == circle::BuiltinOptions_FloorDivOptions
13111              ? static_cast<const circle::FloorDivOptions *>(builtin_options())
13112              : nullptr;
13113   }
13114   const circle::SquareOptions *builtin_options_as_SquareOptions() const
13115   {
13116     return builtin_options_type() == circle::BuiltinOptions_SquareOptions
13117              ? static_cast<const circle::SquareOptions *>(builtin_options())
13118              : nullptr;
13119   }
13120   const circle::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const
13121   {
13122     return builtin_options_type() == circle::BuiltinOptions_ZerosLikeOptions
13123              ? static_cast<const circle::ZerosLikeOptions *>(builtin_options())
13124              : nullptr;
13125   }
13126   const circle::FillOptions *builtin_options_as_FillOptions() const
13127   {
13128     return builtin_options_type() == circle::BuiltinOptions_FillOptions
13129              ? static_cast<const circle::FillOptions *>(builtin_options())
13130              : nullptr;
13131   }
13132   const circle::BidirectionalSequenceLSTMOptions *
13133   builtin_options_as_BidirectionalSequenceLSTMOptions() const
13134   {
13135     return builtin_options_type() == circle::BuiltinOptions_BidirectionalSequenceLSTMOptions
13136              ? static_cast<const circle::BidirectionalSequenceLSTMOptions *>(builtin_options())
13137              : nullptr;
13138   }
13139   const circle::BidirectionalSequenceRNNOptions *
13140   builtin_options_as_BidirectionalSequenceRNNOptions() const
13141   {
13142     return builtin_options_type() == circle::BuiltinOptions_BidirectionalSequenceRNNOptions
13143              ? static_cast<const circle::BidirectionalSequenceRNNOptions *>(builtin_options())
13144              : nullptr;
13145   }
13146   const circle::UnidirectionalSequenceLSTMOptions *
13147   builtin_options_as_UnidirectionalSequenceLSTMOptions() const
13148   {
13149     return builtin_options_type() == circle::BuiltinOptions_UnidirectionalSequenceLSTMOptions
13150              ? static_cast<const circle::UnidirectionalSequenceLSTMOptions *>(builtin_options())
13151              : nullptr;
13152   }
13153   const circle::FloorModOptions *builtin_options_as_FloorModOptions() const
13154   {
13155     return builtin_options_type() == circle::BuiltinOptions_FloorModOptions
13156              ? static_cast<const circle::FloorModOptions *>(builtin_options())
13157              : nullptr;
13158   }
13159   const circle::RangeOptions *builtin_options_as_RangeOptions() const
13160   {
13161     return builtin_options_type() == circle::BuiltinOptions_RangeOptions
13162              ? static_cast<const circle::RangeOptions *>(builtin_options())
13163              : nullptr;
13164   }
13165   const circle::ResizeNearestNeighborOptions *
13166   builtin_options_as_ResizeNearestNeighborOptions() const
13167   {
13168     return builtin_options_type() == circle::BuiltinOptions_ResizeNearestNeighborOptions
13169              ? static_cast<const circle::ResizeNearestNeighborOptions *>(builtin_options())
13170              : nullptr;
13171   }
13172   const circle::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const
13173   {
13174     return builtin_options_type() == circle::BuiltinOptions_LeakyReluOptions
13175              ? static_cast<const circle::LeakyReluOptions *>(builtin_options())
13176              : nullptr;
13177   }
13178   const circle::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const
13179   {
13180     return builtin_options_type() == circle::BuiltinOptions_SquaredDifferenceOptions
13181              ? static_cast<const circle::SquaredDifferenceOptions *>(builtin_options())
13182              : nullptr;
13183   }
13184   const circle::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const
13185   {
13186     return builtin_options_type() == circle::BuiltinOptions_MirrorPadOptions
13187              ? static_cast<const circle::MirrorPadOptions *>(builtin_options())
13188              : nullptr;
13189   }
13190   const circle::AbsOptions *builtin_options_as_AbsOptions() const
13191   {
13192     return builtin_options_type() == circle::BuiltinOptions_AbsOptions
13193              ? static_cast<const circle::AbsOptions *>(builtin_options())
13194              : nullptr;
13195   }
13196   const circle::SplitVOptions *builtin_options_as_SplitVOptions() const
13197   {
13198     return builtin_options_type() == circle::BuiltinOptions_SplitVOptions
13199              ? static_cast<const circle::SplitVOptions *>(builtin_options())
13200              : nullptr;
13201   }
13202   const circle::UniqueOptions *builtin_options_as_UniqueOptions() const
13203   {
13204     return builtin_options_type() == circle::BuiltinOptions_UniqueOptions
13205              ? static_cast<const circle::UniqueOptions *>(builtin_options())
13206              : nullptr;
13207   }
13208   const circle::ReverseV2Options *builtin_options_as_ReverseV2Options() const
13209   {
13210     return builtin_options_type() == circle::BuiltinOptions_ReverseV2Options
13211              ? static_cast<const circle::ReverseV2Options *>(builtin_options())
13212              : nullptr;
13213   }
13214   const circle::AddNOptions *builtin_options_as_AddNOptions() const
13215   {
13216     return builtin_options_type() == circle::BuiltinOptions_AddNOptions
13217              ? static_cast<const circle::AddNOptions *>(builtin_options())
13218              : nullptr;
13219   }
13220   const circle::GatherNdOptions *builtin_options_as_GatherNdOptions() const
13221   {
13222     return builtin_options_type() == circle::BuiltinOptions_GatherNdOptions
13223              ? static_cast<const circle::GatherNdOptions *>(builtin_options())
13224              : nullptr;
13225   }
13226   const circle::CosOptions *builtin_options_as_CosOptions() const
13227   {
13228     return builtin_options_type() == circle::BuiltinOptions_CosOptions
13229              ? static_cast<const circle::CosOptions *>(builtin_options())
13230              : nullptr;
13231   }
13232   const circle::WhereOptions *builtin_options_as_WhereOptions() const
13233   {
13234     return builtin_options_type() == circle::BuiltinOptions_WhereOptions
13235              ? static_cast<const circle::WhereOptions *>(builtin_options())
13236              : nullptr;
13237   }
13238   const circle::RankOptions *builtin_options_as_RankOptions() const
13239   {
13240     return builtin_options_type() == circle::BuiltinOptions_RankOptions
13241              ? static_cast<const circle::RankOptions *>(builtin_options())
13242              : nullptr;
13243   }
13244   const circle::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const
13245   {
13246     return builtin_options_type() == circle::BuiltinOptions_ReverseSequenceOptions
13247              ? static_cast<const circle::ReverseSequenceOptions *>(builtin_options())
13248              : nullptr;
13249   }
13250   const circle::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const
13251   {
13252     return builtin_options_type() == circle::BuiltinOptions_MatrixDiagOptions
13253              ? static_cast<const circle::MatrixDiagOptions *>(builtin_options())
13254              : nullptr;
13255   }
13256   const circle::QuantizeOptions *builtin_options_as_QuantizeOptions() const
13257   {
13258     return builtin_options_type() == circle::BuiltinOptions_QuantizeOptions
13259              ? static_cast<const circle::QuantizeOptions *>(builtin_options())
13260              : nullptr;
13261   }
13262   const circle::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const
13263   {
13264     return builtin_options_type() == circle::BuiltinOptions_MatrixSetDiagOptions
13265              ? static_cast<const circle::MatrixSetDiagOptions *>(builtin_options())
13266              : nullptr;
13267   }
13268   const circle::HardSwishOptions *builtin_options_as_HardSwishOptions() const
13269   {
13270     return builtin_options_type() == circle::BuiltinOptions_HardSwishOptions
13271              ? static_cast<const circle::HardSwishOptions *>(builtin_options())
13272              : nullptr;
13273   }
13274   const circle::IfOptions *builtin_options_as_IfOptions() const
13275   {
13276     return builtin_options_type() == circle::BuiltinOptions_IfOptions
13277              ? static_cast<const circle::IfOptions *>(builtin_options())
13278              : nullptr;
13279   }
13280   const circle::WhileOptions *builtin_options_as_WhileOptions() const
13281   {
13282     return builtin_options_type() == circle::BuiltinOptions_WhileOptions
13283              ? static_cast<const circle::WhileOptions *>(builtin_options())
13284              : nullptr;
13285   }
13286   const circle::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const
13287   {
13288     return builtin_options_type() == circle::BuiltinOptions_DepthToSpaceOptions
13289              ? static_cast<const circle::DepthToSpaceOptions *>(builtin_options())
13290              : nullptr;
13291   }
13292   const circle::NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const
13293   {
13294     return builtin_options_type() == circle::BuiltinOptions_NonMaxSuppressionV4Options
13295              ? static_cast<const circle::NonMaxSuppressionV4Options *>(builtin_options())
13296              : nullptr;
13297   }
13298   const circle::NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const
13299   {
13300     return builtin_options_type() == circle::BuiltinOptions_NonMaxSuppressionV5Options
13301              ? static_cast<const circle::NonMaxSuppressionV5Options *>(builtin_options())
13302              : nullptr;
13303   }
13304   const circle::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const
13305   {
13306     return builtin_options_type() == circle::BuiltinOptions_ScatterNdOptions
13307              ? static_cast<const circle::ScatterNdOptions *>(builtin_options())
13308              : nullptr;
13309   }
13310   const circle::SelectV2Options *builtin_options_as_SelectV2Options() const
13311   {
13312     return builtin_options_type() == circle::BuiltinOptions_SelectV2Options
13313              ? static_cast<const circle::SelectV2Options *>(builtin_options())
13314              : nullptr;
13315   }
13316   const circle::DensifyOptions *builtin_options_as_DensifyOptions() const
13317   {
13318     return builtin_options_type() == circle::BuiltinOptions_DensifyOptions
13319              ? static_cast<const circle::DensifyOptions *>(builtin_options())
13320              : nullptr;
13321   }
13322   const circle::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const
13323   {
13324     return builtin_options_type() == circle::BuiltinOptions_SegmentSumOptions
13325              ? static_cast<const circle::SegmentSumOptions *>(builtin_options())
13326              : nullptr;
13327   }
13328   const circle::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const
13329   {
13330     return builtin_options_type() == circle::BuiltinOptions_BatchMatMulOptions
13331              ? static_cast<const circle::BatchMatMulOptions *>(builtin_options())
13332              : nullptr;
13333   }
13334   const circle::CumsumOptions *builtin_options_as_CumsumOptions() const
13335   {
13336     return builtin_options_type() == circle::BuiltinOptions_CumsumOptions
13337              ? static_cast<const circle::CumsumOptions *>(builtin_options())
13338              : nullptr;
13339   }
13340   const circle::CallOnceOptions *builtin_options_as_CallOnceOptions() const
13341   {
13342     return builtin_options_type() == circle::BuiltinOptions_CallOnceOptions
13343              ? static_cast<const circle::CallOnceOptions *>(builtin_options())
13344              : nullptr;
13345   }
13346   const circle::BroadcastToOptions *builtin_options_as_BroadcastToOptions() const
13347   {
13348     return builtin_options_type() == circle::BuiltinOptions_BroadcastToOptions
13349              ? static_cast<const circle::BroadcastToOptions *>(builtin_options())
13350              : nullptr;
13351   }
13352   const circle::Rfft2dOptions *builtin_options_as_Rfft2dOptions() const
13353   {
13354     return builtin_options_type() == circle::BuiltinOptions_Rfft2dOptions
13355              ? static_cast<const circle::Rfft2dOptions *>(builtin_options())
13356              : nullptr;
13357   }
13358   const circle::Conv3DOptions *builtin_options_as_Conv3DOptions() const
13359   {
13360     return builtin_options_type() == circle::BuiltinOptions_Conv3DOptions
13361              ? static_cast<const circle::Conv3DOptions *>(builtin_options())
13362              : nullptr;
13363   }
13364   const circle::HashtableOptions *builtin_options_as_HashtableOptions() const
13365   {
13366     return builtin_options_type() == circle::BuiltinOptions_HashtableOptions
13367              ? static_cast<const circle::HashtableOptions *>(builtin_options())
13368              : nullptr;
13369   }
13370   const circle::HashtableFindOptions *builtin_options_as_HashtableFindOptions() const
13371   {
13372     return builtin_options_type() == circle::BuiltinOptions_HashtableFindOptions
13373              ? static_cast<const circle::HashtableFindOptions *>(builtin_options())
13374              : nullptr;
13375   }
13376   const circle::HashtableImportOptions *builtin_options_as_HashtableImportOptions() const
13377   {
13378     return builtin_options_type() == circle::BuiltinOptions_HashtableImportOptions
13379              ? static_cast<const circle::HashtableImportOptions *>(builtin_options())
13380              : nullptr;
13381   }
13382   const circle::HashtableSizeOptions *builtin_options_as_HashtableSizeOptions() const
13383   {
13384     return builtin_options_type() == circle::BuiltinOptions_HashtableSizeOptions
13385              ? static_cast<const circle::HashtableSizeOptions *>(builtin_options())
13386              : nullptr;
13387   }
13388   const circle::VarHandleOptions *builtin_options_as_VarHandleOptions() const
13389   {
13390     return builtin_options_type() == circle::BuiltinOptions_VarHandleOptions
13391              ? static_cast<const circle::VarHandleOptions *>(builtin_options())
13392              : nullptr;
13393   }
13394   const circle::ReadVariableOptions *builtin_options_as_ReadVariableOptions() const
13395   {
13396     return builtin_options_type() == circle::BuiltinOptions_ReadVariableOptions
13397              ? static_cast<const circle::ReadVariableOptions *>(builtin_options())
13398              : nullptr;
13399   }
13400   const circle::AssignVariableOptions *builtin_options_as_AssignVariableOptions() const
13401   {
13402     return builtin_options_type() == circle::BuiltinOptions_AssignVariableOptions
13403              ? static_cast<const circle::AssignVariableOptions *>(builtin_options())
13404              : nullptr;
13405   }
13406   const circle::RandomOptions *builtin_options_as_RandomOptions() const
13407   {
13408     return builtin_options_type() == circle::BuiltinOptions_RandomOptions
13409              ? static_cast<const circle::RandomOptions *>(builtin_options())
13410              : nullptr;
13411   }
13412   const circle::BCQGatherOptions *builtin_options_as_BCQGatherOptions() const
13413   {
13414     return builtin_options_type() == circle::BuiltinOptions_BCQGatherOptions
13415              ? static_cast<const circle::BCQGatherOptions *>(builtin_options())
13416              : nullptr;
13417   }
13418   const circle::BCQFullyConnectedOptions *builtin_options_as_BCQFullyConnectedOptions() const
13419   {
13420     return builtin_options_type() == circle::BuiltinOptions_BCQFullyConnectedOptions
13421              ? static_cast<const circle::BCQFullyConnectedOptions *>(builtin_options())
13422              : nullptr;
13423   }
13424   const circle::InstanceNormOptions *builtin_options_as_InstanceNormOptions() const
13425   {
13426     return builtin_options_type() == circle::BuiltinOptions_InstanceNormOptions
13427              ? static_cast<const circle::InstanceNormOptions *>(builtin_options())
13428              : nullptr;
13429   }
13430   const flatbuffers::Vector<uint8_t> *custom_options() const
13431   {
13432     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
13433   }
13434   circle::CustomOptionsFormat custom_options_format() const
13435   {
13436     return static_cast<circle::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
13437   }
13438   const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const
13439   {
13440     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
13441   }
13442   const flatbuffers::Vector<int32_t> *intermediates() const
13443   {
13444     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
13445   }
13446   bool Verify(flatbuffers::Verifier &verifier) const
13447   {
13448     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) &&
13449            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
13450            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
13451            VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) &&
13452            VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
13453            VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
13454            VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && verifier.VerifyVector(custom_options()) &&
13455            VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) &&
13456            VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
13457            verifier.VerifyVector(mutating_variable_inputs()) &&
13458            VerifyOffset(verifier, VT_INTERMEDIATES) && verifier.VerifyVector(intermediates()) &&
13459            verifier.EndTable();
13460   }
13461   OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13462   void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13463   static flatbuffers::Offset<Operator>
13464   Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o,
13465        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13466 };
13467
13468 template <>
13469 inline const circle::Conv2DOptions *Operator::builtin_options_as<circle::Conv2DOptions>() const
13470 {
13471   return builtin_options_as_Conv2DOptions();
13472 }
13473
13474 template <>
13475 inline const circle::DepthwiseConv2DOptions *
13476 Operator::builtin_options_as<circle::DepthwiseConv2DOptions>() const
13477 {
13478   return builtin_options_as_DepthwiseConv2DOptions();
13479 }
13480
13481 template <>
13482 inline const circle::ConcatEmbeddingsOptions *
13483 Operator::builtin_options_as<circle::ConcatEmbeddingsOptions>() const
13484 {
13485   return builtin_options_as_ConcatEmbeddingsOptions();
13486 }
13487
13488 template <>
13489 inline const circle::LSHProjectionOptions *
13490 Operator::builtin_options_as<circle::LSHProjectionOptions>() const
13491 {
13492   return builtin_options_as_LSHProjectionOptions();
13493 }
13494
13495 template <>
13496 inline const circle::Pool2DOptions *Operator::builtin_options_as<circle::Pool2DOptions>() const
13497 {
13498   return builtin_options_as_Pool2DOptions();
13499 }
13500
13501 template <>
13502 inline const circle::SVDFOptions *Operator::builtin_options_as<circle::SVDFOptions>() const
13503 {
13504   return builtin_options_as_SVDFOptions();
13505 }
13506
13507 template <>
13508 inline const circle::RNNOptions *Operator::builtin_options_as<circle::RNNOptions>() const
13509 {
13510   return builtin_options_as_RNNOptions();
13511 }
13512
13513 template <>
13514 inline const circle::FullyConnectedOptions *
13515 Operator::builtin_options_as<circle::FullyConnectedOptions>() const
13516 {
13517   return builtin_options_as_FullyConnectedOptions();
13518 }
13519
13520 template <>
13521 inline const circle::SoftmaxOptions *Operator::builtin_options_as<circle::SoftmaxOptions>() const
13522 {
13523   return builtin_options_as_SoftmaxOptions();
13524 }
13525
13526 template <>
13527 inline const circle::ConcatenationOptions *
13528 Operator::builtin_options_as<circle::ConcatenationOptions>() const
13529 {
13530   return builtin_options_as_ConcatenationOptions();
13531 }
13532
13533 template <>
13534 inline const circle::AddOptions *Operator::builtin_options_as<circle::AddOptions>() const
13535 {
13536   return builtin_options_as_AddOptions();
13537 }
13538
13539 template <>
13540 inline const circle::L2NormOptions *Operator::builtin_options_as<circle::L2NormOptions>() const
13541 {
13542   return builtin_options_as_L2NormOptions();
13543 }
13544
13545 template <>
13546 inline const circle::LocalResponseNormalizationOptions *
13547 Operator::builtin_options_as<circle::LocalResponseNormalizationOptions>() const
13548 {
13549   return builtin_options_as_LocalResponseNormalizationOptions();
13550 }
13551
13552 template <>
13553 inline const circle::LSTMOptions *Operator::builtin_options_as<circle::LSTMOptions>() const
13554 {
13555   return builtin_options_as_LSTMOptions();
13556 }
13557
13558 template <>
13559 inline const circle::ResizeBilinearOptions *
13560 Operator::builtin_options_as<circle::ResizeBilinearOptions>() const
13561 {
13562   return builtin_options_as_ResizeBilinearOptions();
13563 }
13564
13565 template <>
13566 inline const circle::CallOptions *Operator::builtin_options_as<circle::CallOptions>() const
13567 {
13568   return builtin_options_as_CallOptions();
13569 }
13570
13571 template <>
13572 inline const circle::ReshapeOptions *Operator::builtin_options_as<circle::ReshapeOptions>() const
13573 {
13574   return builtin_options_as_ReshapeOptions();
13575 }
13576
13577 template <>
13578 inline const circle::SkipGramOptions *Operator::builtin_options_as<circle::SkipGramOptions>() const
13579 {
13580   return builtin_options_as_SkipGramOptions();
13581 }
13582
13583 template <>
13584 inline const circle::SpaceToDepthOptions *
13585 Operator::builtin_options_as<circle::SpaceToDepthOptions>() const
13586 {
13587   return builtin_options_as_SpaceToDepthOptions();
13588 }
13589
13590 template <>
13591 inline const circle::EmbeddingLookupSparseOptions *
13592 Operator::builtin_options_as<circle::EmbeddingLookupSparseOptions>() const
13593 {
13594   return builtin_options_as_EmbeddingLookupSparseOptions();
13595 }
13596
13597 template <>
13598 inline const circle::MulOptions *Operator::builtin_options_as<circle::MulOptions>() const
13599 {
13600   return builtin_options_as_MulOptions();
13601 }
13602
13603 template <>
13604 inline const circle::PadOptions *Operator::builtin_options_as<circle::PadOptions>() const
13605 {
13606   return builtin_options_as_PadOptions();
13607 }
13608
13609 template <>
13610 inline const circle::GatherOptions *Operator::builtin_options_as<circle::GatherOptions>() const
13611 {
13612   return builtin_options_as_GatherOptions();
13613 }
13614
13615 template <>
13616 inline const circle::BatchToSpaceNDOptions *
13617 Operator::builtin_options_as<circle::BatchToSpaceNDOptions>() const
13618 {
13619   return builtin_options_as_BatchToSpaceNDOptions();
13620 }
13621
13622 template <>
13623 inline const circle::SpaceToBatchNDOptions *
13624 Operator::builtin_options_as<circle::SpaceToBatchNDOptions>() const
13625 {
13626   return builtin_options_as_SpaceToBatchNDOptions();
13627 }
13628
13629 template <>
13630 inline const circle::TransposeOptions *
13631 Operator::builtin_options_as<circle::TransposeOptions>() const
13632 {
13633   return builtin_options_as_TransposeOptions();
13634 }
13635
13636 template <>
13637 inline const circle::ReducerOptions *Operator::builtin_options_as<circle::ReducerOptions>() const
13638 {
13639   return builtin_options_as_ReducerOptions();
13640 }
13641
13642 template <>
13643 inline const circle::SubOptions *Operator::builtin_options_as<circle::SubOptions>() const
13644 {
13645   return builtin_options_as_SubOptions();
13646 }
13647
13648 template <>
13649 inline const circle::DivOptions *Operator::builtin_options_as<circle::DivOptions>() const
13650 {
13651   return builtin_options_as_DivOptions();
13652 }
13653
13654 template <>
13655 inline const circle::SqueezeOptions *Operator::builtin_options_as<circle::SqueezeOptions>() const
13656 {
13657   return builtin_options_as_SqueezeOptions();
13658 }
13659
13660 template <>
13661 inline const circle::SequenceRNNOptions *
13662 Operator::builtin_options_as<circle::SequenceRNNOptions>() const
13663 {
13664   return builtin_options_as_SequenceRNNOptions();
13665 }
13666
13667 template <>
13668 inline const circle::StridedSliceOptions *
13669 Operator::builtin_options_as<circle::StridedSliceOptions>() const
13670 {
13671   return builtin_options_as_StridedSliceOptions();
13672 }
13673
13674 template <>
13675 inline const circle::ExpOptions *Operator::builtin_options_as<circle::ExpOptions>() const
13676 {
13677   return builtin_options_as_ExpOptions();
13678 }
13679
13680 template <>
13681 inline const circle::TopKV2Options *Operator::builtin_options_as<circle::TopKV2Options>() const
13682 {
13683   return builtin_options_as_TopKV2Options();
13684 }
13685
13686 template <>
13687 inline const circle::SplitOptions *Operator::builtin_options_as<circle::SplitOptions>() const
13688 {
13689   return builtin_options_as_SplitOptions();
13690 }
13691
13692 template <>
13693 inline const circle::LogSoftmaxOptions *
13694 Operator::builtin_options_as<circle::LogSoftmaxOptions>() const
13695 {
13696   return builtin_options_as_LogSoftmaxOptions();
13697 }
13698
13699 template <>
13700 inline const circle::CastOptions *Operator::builtin_options_as<circle::CastOptions>() const
13701 {
13702   return builtin_options_as_CastOptions();
13703 }
13704
13705 template <>
13706 inline const circle::DequantizeOptions *
13707 Operator::builtin_options_as<circle::DequantizeOptions>() const
13708 {
13709   return builtin_options_as_DequantizeOptions();
13710 }
13711
13712 template <>
13713 inline const circle::MaximumMinimumOptions *
13714 Operator::builtin_options_as<circle::MaximumMinimumOptions>() const
13715 {
13716   return builtin_options_as_MaximumMinimumOptions();
13717 }
13718
13719 template <>
13720 inline const circle::ArgMaxOptions *Operator::builtin_options_as<circle::ArgMaxOptions>() const
13721 {
13722   return builtin_options_as_ArgMaxOptions();
13723 }
13724
13725 template <>
13726 inline const circle::LessOptions *Operator::builtin_options_as<circle::LessOptions>() const
13727 {
13728   return builtin_options_as_LessOptions();
13729 }
13730
13731 template <>
13732 inline const circle::NegOptions *Operator::builtin_options_as<circle::NegOptions>() const
13733 {
13734   return builtin_options_as_NegOptions();
13735 }
13736
13737 template <>
13738 inline const circle::PadV2Options *Operator::builtin_options_as<circle::PadV2Options>() const
13739 {
13740   return builtin_options_as_PadV2Options();
13741 }
13742
13743 template <>
13744 inline const circle::GreaterOptions *Operator::builtin_options_as<circle::GreaterOptions>() const
13745 {
13746   return builtin_options_as_GreaterOptions();
13747 }
13748
13749 template <>
13750 inline const circle::GreaterEqualOptions *
13751 Operator::builtin_options_as<circle::GreaterEqualOptions>() const
13752 {
13753   return builtin_options_as_GreaterEqualOptions();
13754 }
13755
13756 template <>
13757 inline const circle::LessEqualOptions *
13758 Operator::builtin_options_as<circle::LessEqualOptions>() const
13759 {
13760   return builtin_options_as_LessEqualOptions();
13761 }
13762
13763 template <>
13764 inline const circle::SelectOptions *Operator::builtin_options_as<circle::SelectOptions>() const
13765 {
13766   return builtin_options_as_SelectOptions();
13767 }
13768
13769 template <>
13770 inline const circle::SliceOptions *Operator::builtin_options_as<circle::SliceOptions>() const
13771 {
13772   return builtin_options_as_SliceOptions();
13773 }
13774
13775 template <>
13776 inline const circle::TransposeConvOptions *
13777 Operator::builtin_options_as<circle::TransposeConvOptions>() const
13778 {
13779   return builtin_options_as_TransposeConvOptions();
13780 }
13781
13782 template <>
13783 inline const circle::SparseToDenseOptions *
13784 Operator::builtin_options_as<circle::SparseToDenseOptions>() const
13785 {
13786   return builtin_options_as_SparseToDenseOptions();
13787 }
13788
13789 template <>
13790 inline const circle::TileOptions *Operator::builtin_options_as<circle::TileOptions>() const
13791 {
13792   return builtin_options_as_TileOptions();
13793 }
13794
13795 template <>
13796 inline const circle::ExpandDimsOptions *
13797 Operator::builtin_options_as<circle::ExpandDimsOptions>() const
13798 {
13799   return builtin_options_as_ExpandDimsOptions();
13800 }
13801
13802 template <>
13803 inline const circle::EqualOptions *Operator::builtin_options_as<circle::EqualOptions>() const
13804 {
13805   return builtin_options_as_EqualOptions();
13806 }
13807
13808 template <>
13809 inline const circle::NotEqualOptions *Operator::builtin_options_as<circle::NotEqualOptions>() const
13810 {
13811   return builtin_options_as_NotEqualOptions();
13812 }
13813
13814 template <>
13815 inline const circle::ShapeOptions *Operator::builtin_options_as<circle::ShapeOptions>() const
13816 {
13817   return builtin_options_as_ShapeOptions();
13818 }
13819
13820 template <>
13821 inline const circle::PowOptions *Operator::builtin_options_as<circle::PowOptions>() const
13822 {
13823   return builtin_options_as_PowOptions();
13824 }
13825
13826 template <>
13827 inline const circle::ArgMinOptions *Operator::builtin_options_as<circle::ArgMinOptions>() const
13828 {
13829   return builtin_options_as_ArgMinOptions();
13830 }
13831
13832 template <>
13833 inline const circle::FakeQuantOptions *
13834 Operator::builtin_options_as<circle::FakeQuantOptions>() const
13835 {
13836   return builtin_options_as_FakeQuantOptions();
13837 }
13838
13839 template <>
13840 inline const circle::PackOptions *Operator::builtin_options_as<circle::PackOptions>() const
13841 {
13842   return builtin_options_as_PackOptions();
13843 }
13844
13845 template <>
13846 inline const circle::LogicalOrOptions *
13847 Operator::builtin_options_as<circle::LogicalOrOptions>() const
13848 {
13849   return builtin_options_as_LogicalOrOptions();
13850 }
13851
13852 template <>
13853 inline const circle::OneHotOptions *Operator::builtin_options_as<circle::OneHotOptions>() const
13854 {
13855   return builtin_options_as_OneHotOptions();
13856 }
13857
13858 template <>
13859 inline const circle::LogicalAndOptions *
13860 Operator::builtin_options_as<circle::LogicalAndOptions>() const
13861 {
13862   return builtin_options_as_LogicalAndOptions();
13863 }
13864
13865 template <>
13866 inline const circle::LogicalNotOptions *
13867 Operator::builtin_options_as<circle::LogicalNotOptions>() const
13868 {
13869   return builtin_options_as_LogicalNotOptions();
13870 }
13871
13872 template <>
13873 inline const circle::UnpackOptions *Operator::builtin_options_as<circle::UnpackOptions>() const
13874 {
13875   return builtin_options_as_UnpackOptions();
13876 }
13877
13878 template <>
13879 inline const circle::FloorDivOptions *Operator::builtin_options_as<circle::FloorDivOptions>() const
13880 {
13881   return builtin_options_as_FloorDivOptions();
13882 }
13883
13884 template <>
13885 inline const circle::SquareOptions *Operator::builtin_options_as<circle::SquareOptions>() const
13886 {
13887   return builtin_options_as_SquareOptions();
13888 }
13889
13890 template <>
13891 inline const circle::ZerosLikeOptions *
13892 Operator::builtin_options_as<circle::ZerosLikeOptions>() const
13893 {
13894   return builtin_options_as_ZerosLikeOptions();
13895 }
13896
13897 template <>
13898 inline const circle::FillOptions *Operator::builtin_options_as<circle::FillOptions>() const
13899 {
13900   return builtin_options_as_FillOptions();
13901 }
13902
13903 template <>
13904 inline const circle::BidirectionalSequenceLSTMOptions *
13905 Operator::builtin_options_as<circle::BidirectionalSequenceLSTMOptions>() const
13906 {
13907   return builtin_options_as_BidirectionalSequenceLSTMOptions();
13908 }
13909
13910 template <>
13911 inline const circle::BidirectionalSequenceRNNOptions *
13912 Operator::builtin_options_as<circle::BidirectionalSequenceRNNOptions>() const
13913 {
13914   return builtin_options_as_BidirectionalSequenceRNNOptions();
13915 }
13916
13917 template <>
13918 inline const circle::UnidirectionalSequenceLSTMOptions *
13919 Operator::builtin_options_as<circle::UnidirectionalSequenceLSTMOptions>() const
13920 {
13921   return builtin_options_as_UnidirectionalSequenceLSTMOptions();
13922 }
13923
13924 template <>
13925 inline const circle::FloorModOptions *Operator::builtin_options_as<circle::FloorModOptions>() const
13926 {
13927   return builtin_options_as_FloorModOptions();
13928 }
13929
13930 template <>
13931 inline const circle::RangeOptions *Operator::builtin_options_as<circle::RangeOptions>() const
13932 {
13933   return builtin_options_as_RangeOptions();
13934 }
13935
13936 template <>
13937 inline const circle::ResizeNearestNeighborOptions *
13938 Operator::builtin_options_as<circle::ResizeNearestNeighborOptions>() const
13939 {
13940   return builtin_options_as_ResizeNearestNeighborOptions();
13941 }
13942
13943 template <>
13944 inline const circle::LeakyReluOptions *
13945 Operator::builtin_options_as<circle::LeakyReluOptions>() const
13946 {
13947   return builtin_options_as_LeakyReluOptions();
13948 }
13949
13950 template <>
13951 inline const circle::SquaredDifferenceOptions *
13952 Operator::builtin_options_as<circle::SquaredDifferenceOptions>() const
13953 {
13954   return builtin_options_as_SquaredDifferenceOptions();
13955 }
13956
13957 template <>
13958 inline const circle::MirrorPadOptions *
13959 Operator::builtin_options_as<circle::MirrorPadOptions>() const
13960 {
13961   return builtin_options_as_MirrorPadOptions();
13962 }
13963
13964 template <>
13965 inline const circle::AbsOptions *Operator::builtin_options_as<circle::AbsOptions>() const
13966 {
13967   return builtin_options_as_AbsOptions();
13968 }
13969
13970 template <>
13971 inline const circle::SplitVOptions *Operator::builtin_options_as<circle::SplitVOptions>() const
13972 {
13973   return builtin_options_as_SplitVOptions();
13974 }
13975
13976 template <>
13977 inline const circle::UniqueOptions *Operator::builtin_options_as<circle::UniqueOptions>() const
13978 {
13979   return builtin_options_as_UniqueOptions();
13980 }
13981
13982 template <>
13983 inline const circle::ReverseV2Options *
13984 Operator::builtin_options_as<circle::ReverseV2Options>() const
13985 {
13986   return builtin_options_as_ReverseV2Options();
13987 }
13988
13989 template <>
13990 inline const circle::AddNOptions *Operator::builtin_options_as<circle::AddNOptions>() const
13991 {
13992   return builtin_options_as_AddNOptions();
13993 }
13994
13995 template <>
13996 inline const circle::GatherNdOptions *Operator::builtin_options_as<circle::GatherNdOptions>() const
13997 {
13998   return builtin_options_as_GatherNdOptions();
13999 }
14000
14001 template <>
14002 inline const circle::CosOptions *Operator::builtin_options_as<circle::CosOptions>() const
14003 {
14004   return builtin_options_as_CosOptions();
14005 }
14006
14007 template <>
14008 inline const circle::WhereOptions *Operator::builtin_options_as<circle::WhereOptions>() const
14009 {
14010   return builtin_options_as_WhereOptions();
14011 }
14012
14013 template <>
14014 inline const circle::RankOptions *Operator::builtin_options_as<circle::RankOptions>() const
14015 {
14016   return builtin_options_as_RankOptions();
14017 }
14018
14019 template <>
14020 inline const circle::ReverseSequenceOptions *
14021 Operator::builtin_options_as<circle::ReverseSequenceOptions>() const
14022 {
14023   return builtin_options_as_ReverseSequenceOptions();
14024 }
14025
14026 template <>
14027 inline const circle::MatrixDiagOptions *
14028 Operator::builtin_options_as<circle::MatrixDiagOptions>() const
14029 {
14030   return builtin_options_as_MatrixDiagOptions();
14031 }
14032
14033 template <>
14034 inline const circle::QuantizeOptions *Operator::builtin_options_as<circle::QuantizeOptions>() const
14035 {
14036   return builtin_options_as_QuantizeOptions();
14037 }
14038
14039 template <>
14040 inline const circle::MatrixSetDiagOptions *
14041 Operator::builtin_options_as<circle::MatrixSetDiagOptions>() const
14042 {
14043   return builtin_options_as_MatrixSetDiagOptions();
14044 }
14045
14046 template <>
14047 inline const circle::HardSwishOptions *
14048 Operator::builtin_options_as<circle::HardSwishOptions>() const
14049 {
14050   return builtin_options_as_HardSwishOptions();
14051 }
14052
14053 template <> inline const circle::IfOptions *Operator::builtin_options_as<circle::IfOptions>() const
14054 {
14055   return builtin_options_as_IfOptions();
14056 }
14057
14058 template <>
14059 inline const circle::WhileOptions *Operator::builtin_options_as<circle::WhileOptions>() const
14060 {
14061   return builtin_options_as_WhileOptions();
14062 }
14063
14064 template <>
14065 inline const circle::DepthToSpaceOptions *
14066 Operator::builtin_options_as<circle::DepthToSpaceOptions>() const
14067 {
14068   return builtin_options_as_DepthToSpaceOptions();
14069 }
14070
14071 template <>
14072 inline const circle::NonMaxSuppressionV4Options *
14073 Operator::builtin_options_as<circle::NonMaxSuppressionV4Options>() const
14074 {
14075   return builtin_options_as_NonMaxSuppressionV4Options();
14076 }
14077
14078 template <>
14079 inline const circle::NonMaxSuppressionV5Options *
14080 Operator::builtin_options_as<circle::NonMaxSuppressionV5Options>() const
14081 {
14082   return builtin_options_as_NonMaxSuppressionV5Options();
14083 }
14084
14085 template <>
14086 inline const circle::ScatterNdOptions *
14087 Operator::builtin_options_as<circle::ScatterNdOptions>() const
14088 {
14089   return builtin_options_as_ScatterNdOptions();
14090 }
14091
14092 template <>
14093 inline const circle::SelectV2Options *Operator::builtin_options_as<circle::SelectV2Options>() const
14094 {
14095   return builtin_options_as_SelectV2Options();
14096 }
14097
14098 template <>
14099 inline const circle::DensifyOptions *Operator::builtin_options_as<circle::DensifyOptions>() const
14100 {
14101   return builtin_options_as_DensifyOptions();
14102 }
14103
14104 template <>
14105 inline const circle::SegmentSumOptions *
14106 Operator::builtin_options_as<circle::SegmentSumOptions>() const
14107 {
14108   return builtin_options_as_SegmentSumOptions();
14109 }
14110
14111 template <>
14112 inline const circle::BatchMatMulOptions *
14113 Operator::builtin_options_as<circle::BatchMatMulOptions>() const
14114 {
14115   return builtin_options_as_BatchMatMulOptions();
14116 }
14117
14118 template <>
14119 inline const circle::CumsumOptions *Operator::builtin_options_as<circle::CumsumOptions>() const
14120 {
14121   return builtin_options_as_CumsumOptions();
14122 }
14123
14124 template <>
14125 inline const circle::CallOnceOptions *Operator::builtin_options_as<circle::CallOnceOptions>() const
14126 {
14127   return builtin_options_as_CallOnceOptions();
14128 }
14129
14130 template <>
14131 inline const circle::BroadcastToOptions *
14132 Operator::builtin_options_as<circle::BroadcastToOptions>() const
14133 {
14134   return builtin_options_as_BroadcastToOptions();
14135 }
14136
14137 template <>
14138 inline const circle::Rfft2dOptions *Operator::builtin_options_as<circle::Rfft2dOptions>() const
14139 {
14140   return builtin_options_as_Rfft2dOptions();
14141 }
14142
14143 template <>
14144 inline const circle::Conv3DOptions *Operator::builtin_options_as<circle::Conv3DOptions>() const
14145 {
14146   return builtin_options_as_Conv3DOptions();
14147 }
14148
14149 template <>
14150 inline const circle::HashtableOptions *
14151 Operator::builtin_options_as<circle::HashtableOptions>() const
14152 {
14153   return builtin_options_as_HashtableOptions();
14154 }
14155
14156 template <>
14157 inline const circle::HashtableFindOptions *
14158 Operator::builtin_options_as<circle::HashtableFindOptions>() const
14159 {
14160   return builtin_options_as_HashtableFindOptions();
14161 }
14162
14163 template <>
14164 inline const circle::HashtableImportOptions *
14165 Operator::builtin_options_as<circle::HashtableImportOptions>() const
14166 {
14167   return builtin_options_as_HashtableImportOptions();
14168 }
14169
14170 template <>
14171 inline const circle::HashtableSizeOptions *
14172 Operator::builtin_options_as<circle::HashtableSizeOptions>() const
14173 {
14174   return builtin_options_as_HashtableSizeOptions();
14175 }
14176
14177 template <>
14178 inline const circle::VarHandleOptions *
14179 Operator::builtin_options_as<circle::VarHandleOptions>() const
14180 {
14181   return builtin_options_as_VarHandleOptions();
14182 }
14183
14184 template <>
14185 inline const circle::ReadVariableOptions *
14186 Operator::builtin_options_as<circle::ReadVariableOptions>() const
14187 {
14188   return builtin_options_as_ReadVariableOptions();
14189 }
14190
14191 template <>
14192 inline const circle::AssignVariableOptions *
14193 Operator::builtin_options_as<circle::AssignVariableOptions>() const
14194 {
14195   return builtin_options_as_AssignVariableOptions();
14196 }
14197
14198 template <>
14199 inline const circle::RandomOptions *Operator::builtin_options_as<circle::RandomOptions>() const
14200 {
14201   return builtin_options_as_RandomOptions();
14202 }
14203
14204 template <>
14205 inline const circle::BCQGatherOptions *
14206 Operator::builtin_options_as<circle::BCQGatherOptions>() const
14207 {
14208   return builtin_options_as_BCQGatherOptions();
14209 }
14210
14211 template <>
14212 inline const circle::BCQFullyConnectedOptions *
14213 Operator::builtin_options_as<circle::BCQFullyConnectedOptions>() const
14214 {
14215   return builtin_options_as_BCQFullyConnectedOptions();
14216 }
14217
14218 template <>
14219 inline const circle::InstanceNormOptions *
14220 Operator::builtin_options_as<circle::InstanceNormOptions>() const
14221 {
14222   return builtin_options_as_InstanceNormOptions();
14223 }
14224
14225 struct OperatorBuilder
14226 {
14227   typedef Operator Table;
14228   flatbuffers::FlatBufferBuilder &fbb_;
14229   flatbuffers::uoffset_t start_;
14230   void add_opcode_index(uint32_t opcode_index)
14231   {
14232     fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
14233   }
14234   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
14235   {
14236     fbb_.AddOffset(Operator::VT_INPUTS, inputs);
14237   }
14238   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
14239   {
14240     fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
14241   }
14242   void add_builtin_options_type(circle::BuiltinOptions builtin_options_type)
14243   {
14244     fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE,
14245                              static_cast<uint8_t>(builtin_options_type), 0);
14246   }
14247   void add_builtin_options(flatbuffers::Offset<void> builtin_options)
14248   {
14249     fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
14250   }
14251   void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options)
14252   {
14253     fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
14254   }
14255   void add_custom_options_format(circle::CustomOptionsFormat custom_options_format)
14256   {
14257     fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT,
14258                             static_cast<int8_t>(custom_options_format), 0);
14259   }
14260   void add_mutating_variable_inputs(
14261     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs)
14262   {
14263     fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
14264   }
14265   void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates)
14266   {
14267     fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
14268   }
14269   explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14270   {
14271     start_ = fbb_.StartTable();
14272   }
14273   flatbuffers::Offset<Operator> Finish()
14274   {
14275     const auto end = fbb_.EndTable(start_);
14276     auto o = flatbuffers::Offset<Operator>(end);
14277     return o;
14278   }
14279 };
14280
14281 inline flatbuffers::Offset<Operator> CreateOperator(
14282   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
14283   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
14284   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
14285   circle::BuiltinOptions builtin_options_type = circle::BuiltinOptions_NONE,
14286   flatbuffers::Offset<void> builtin_options = 0,
14287   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
14288   circle::CustomOptionsFormat custom_options_format = circle::CustomOptionsFormat_FLEXBUFFERS,
14289   flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
14290   flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0)
14291 {
14292   OperatorBuilder builder_(_fbb);
14293   builder_.add_intermediates(intermediates);
14294   builder_.add_mutating_variable_inputs(mutating_variable_inputs);
14295   builder_.add_custom_options(custom_options);
14296   builder_.add_builtin_options(builtin_options);
14297   builder_.add_outputs(outputs);
14298   builder_.add_inputs(inputs);
14299   builder_.add_opcode_index(opcode_index);
14300   builder_.add_custom_options_format(custom_options_format);
14301   builder_.add_builtin_options_type(builtin_options_type);
14302   return builder_.Finish();
14303 }
14304
14305 inline flatbuffers::Offset<Operator> CreateOperatorDirect(
14306   flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index = 0,
14307   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
14308   circle::BuiltinOptions builtin_options_type = circle::BuiltinOptions_NONE,
14309   flatbuffers::Offset<void> builtin_options = 0,
14310   const std::vector<uint8_t> *custom_options = nullptr,
14311   circle::CustomOptionsFormat custom_options_format = circle::CustomOptionsFormat_FLEXBUFFERS,
14312   const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
14313   const std::vector<int32_t> *intermediates = nullptr)
14314 {
14315   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
14316   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
14317   auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
14318   auto mutating_variable_inputs__ =
14319     mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
14320   auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
14321   return circle::CreateOperator(_fbb, opcode_index, inputs__, outputs__, builtin_options_type,
14322                                 builtin_options, custom_options__, custom_options_format,
14323                                 mutating_variable_inputs__, intermediates__);
14324 }
14325
14326 flatbuffers::Offset<Operator>
14327 CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o,
14328                const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14329
14330 struct SubGraphT : public flatbuffers::NativeTable
14331 {
14332   typedef SubGraph TableType;
14333   std::vector<std::unique_ptr<circle::TensorT>> tensors{};
14334   std::vector<int32_t> inputs{};
14335   std::vector<int32_t> outputs{};
14336   std::vector<std::unique_ptr<circle::OperatorT>> operators{};
14337   std::string name{};
14338   circle::DataFormat data_format = circle::DataFormat_CHANNELS_LAST;
14339 };
14340
14341 struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14342 {
14343   typedef SubGraphT NativeTableType;
14344   typedef SubGraphBuilder Builder;
14345   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14346   {
14347     VT_TENSORS = 4,
14348     VT_INPUTS = 6,
14349     VT_OUTPUTS = 8,
14350     VT_OPERATORS = 10,
14351     VT_NAME = 12,
14352     VT_DATA_FORMAT = 14
14353   };
14354   const flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>> *tensors() const
14355   {
14356     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>> *>(VT_TENSORS);
14357   }
14358   const flatbuffers::Vector<int32_t> *inputs() const
14359   {
14360     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
14361   }
14362   const flatbuffers::Vector<int32_t> *outputs() const
14363   {
14364     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
14365   }
14366   const flatbuffers::Vector<flatbuffers::Offset<circle::Operator>> *operators() const
14367   {
14368     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Operator>> *>(
14369       VT_OPERATORS);
14370   }
14371   const flatbuffers::String *name() const
14372   {
14373     return GetPointer<const flatbuffers::String *>(VT_NAME);
14374   }
14375   circle::DataFormat data_format() const
14376   {
14377     return static_cast<circle::DataFormat>(GetField<int8_t>(VT_DATA_FORMAT, 0));
14378   }
14379   bool Verify(flatbuffers::Verifier &verifier) const
14380   {
14381     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TENSORS) &&
14382            verifier.VerifyVector(tensors()) && verifier.VerifyVectorOfTables(tensors()) &&
14383            VerifyOffset(verifier, VT_INPUTS) && verifier.VerifyVector(inputs()) &&
14384            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
14385            VerifyOffset(verifier, VT_OPERATORS) && verifier.VerifyVector(operators()) &&
14386            verifier.VerifyVectorOfTables(operators()) && VerifyOffset(verifier, VT_NAME) &&
14387            verifier.VerifyString(name()) && VerifyField<int8_t>(verifier, VT_DATA_FORMAT) &&
14388            verifier.EndTable();
14389   }
14390   SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14391   void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14392   static flatbuffers::Offset<SubGraph>
14393   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o,
14394        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14395 };
14396
14397 struct SubGraphBuilder
14398 {
14399   typedef SubGraph Table;
14400   flatbuffers::FlatBufferBuilder &fbb_;
14401   flatbuffers::uoffset_t start_;
14402   void
14403   add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>>> tensors)
14404   {
14405     fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
14406   }
14407   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs)
14408   {
14409     fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
14410   }
14411   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs)
14412   {
14413     fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
14414   }
14415   void add_operators(
14416     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Operator>>> operators)
14417   {
14418     fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
14419   }
14420   void add_name(flatbuffers::Offset<flatbuffers::String> name)
14421   {
14422     fbb_.AddOffset(SubGraph::VT_NAME, name);
14423   }
14424   void add_data_format(circle::DataFormat data_format)
14425   {
14426     fbb_.AddElement<int8_t>(SubGraph::VT_DATA_FORMAT, static_cast<int8_t>(data_format), 0);
14427   }
14428   explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14429   {
14430     start_ = fbb_.StartTable();
14431   }
14432   flatbuffers::Offset<SubGraph> Finish()
14433   {
14434     const auto end = fbb_.EndTable(start_);
14435     auto o = flatbuffers::Offset<SubGraph>(end);
14436     return o;
14437   }
14438 };
14439
14440 inline flatbuffers::Offset<SubGraph> CreateSubGraph(
14441   flatbuffers::FlatBufferBuilder &_fbb,
14442   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>>> tensors = 0,
14443   flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
14444   flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
14445   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Operator>>> operators = 0,
14446   flatbuffers::Offset<flatbuffers::String> name = 0,
14447   circle::DataFormat data_format = circle::DataFormat_CHANNELS_LAST)
14448 {
14449   SubGraphBuilder builder_(_fbb);
14450   builder_.add_name(name);
14451   builder_.add_operators(operators);
14452   builder_.add_outputs(outputs);
14453   builder_.add_inputs(inputs);
14454   builder_.add_tensors(tensors);
14455   builder_.add_data_format(data_format);
14456   return builder_.Finish();
14457 }
14458
14459 inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
14460   flatbuffers::FlatBufferBuilder &_fbb,
14461   const std::vector<flatbuffers::Offset<circle::Tensor>> *tensors = nullptr,
14462   const std::vector<int32_t> *inputs = nullptr, const std::vector<int32_t> *outputs = nullptr,
14463   const std::vector<flatbuffers::Offset<circle::Operator>> *operators = nullptr,
14464   const char *name = nullptr, circle::DataFormat data_format = circle::DataFormat_CHANNELS_LAST)
14465 {
14466   auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<circle::Tensor>>(*tensors) : 0;
14467   auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
14468   auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
14469   auto operators__ =
14470     operators ? _fbb.CreateVector<flatbuffers::Offset<circle::Operator>>(*operators) : 0;
14471   auto name__ = name ? _fbb.CreateString(name) : 0;
14472   return circle::CreateSubGraph(_fbb, tensors__, inputs__, outputs__, operators__, name__,
14473                                 data_format);
14474 }
14475
14476 flatbuffers::Offset<SubGraph>
14477 CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o,
14478                const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14479
14480 struct BufferT : public flatbuffers::NativeTable
14481 {
14482   typedef Buffer TableType;
14483   std::vector<uint8_t> data{};
14484 };
14485
14486 struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14487 {
14488   typedef BufferT NativeTableType;
14489   typedef BufferBuilder Builder;
14490   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14491   {
14492     VT_DATA = 4
14493   };
14494   const flatbuffers::Vector<uint8_t> *data() const
14495   {
14496     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
14497   }
14498   bool Verify(flatbuffers::Verifier &verifier) const
14499   {
14500     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA) &&
14501            verifier.VerifyVector(data()) && verifier.EndTable();
14502   }
14503   BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14504   void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14505   static flatbuffers::Offset<Buffer>
14506   Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o,
14507        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14508 };
14509
14510 struct BufferBuilder
14511 {
14512   typedef Buffer Table;
14513   flatbuffers::FlatBufferBuilder &fbb_;
14514   flatbuffers::uoffset_t start_;
14515   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data)
14516   {
14517     fbb_.AddOffset(Buffer::VT_DATA, data);
14518   }
14519   explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14520   {
14521     start_ = fbb_.StartTable();
14522   }
14523   flatbuffers::Offset<Buffer> Finish()
14524   {
14525     const auto end = fbb_.EndTable(start_);
14526     auto o = flatbuffers::Offset<Buffer>(end);
14527     return o;
14528   }
14529 };
14530
14531 inline flatbuffers::Offset<Buffer>
14532 CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb,
14533              flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0)
14534 {
14535   BufferBuilder builder_(_fbb);
14536   builder_.add_data(data);
14537   return builder_.Finish();
14538 }
14539
14540 inline flatbuffers::Offset<Buffer> CreateBufferDirect(flatbuffers::FlatBufferBuilder &_fbb,
14541                                                       const std::vector<uint8_t> *data = nullptr)
14542 {
14543   if (data)
14544   {
14545     _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16);
14546   }
14547   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
14548   return circle::CreateBuffer(_fbb, data__);
14549 }
14550
14551 flatbuffers::Offset<Buffer>
14552 CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o,
14553              const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14554
14555 struct MetadataT : public flatbuffers::NativeTable
14556 {
14557   typedef Metadata TableType;
14558   std::string name{};
14559   uint32_t buffer = 0;
14560 };
14561
14562 struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14563 {
14564   typedef MetadataT NativeTableType;
14565   typedef MetadataBuilder Builder;
14566   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14567   {
14568     VT_NAME = 4,
14569     VT_BUFFER = 6
14570   };
14571   const flatbuffers::String *name() const
14572   {
14573     return GetPointer<const flatbuffers::String *>(VT_NAME);
14574   }
14575   uint32_t buffer() const { return GetField<uint32_t>(VT_BUFFER, 0); }
14576   bool Verify(flatbuffers::Verifier &verifier) const
14577   {
14578     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
14579            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_BUFFER) &&
14580            verifier.EndTable();
14581   }
14582   MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14583   void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14584   static flatbuffers::Offset<Metadata>
14585   Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o,
14586        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14587 };
14588
14589 struct MetadataBuilder
14590 {
14591   typedef Metadata Table;
14592   flatbuffers::FlatBufferBuilder &fbb_;
14593   flatbuffers::uoffset_t start_;
14594   void add_name(flatbuffers::Offset<flatbuffers::String> name)
14595   {
14596     fbb_.AddOffset(Metadata::VT_NAME, name);
14597   }
14598   void add_buffer(uint32_t buffer) { fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0); }
14599   explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14600   {
14601     start_ = fbb_.StartTable();
14602   }
14603   flatbuffers::Offset<Metadata> Finish()
14604   {
14605     const auto end = fbb_.EndTable(start_);
14606     auto o = flatbuffers::Offset<Metadata>(end);
14607     return o;
14608   }
14609 };
14610
14611 inline flatbuffers::Offset<Metadata>
14612 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb,
14613                flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t buffer = 0)
14614 {
14615   MetadataBuilder builder_(_fbb);
14616   builder_.add_buffer(buffer);
14617   builder_.add_name(name);
14618   return builder_.Finish();
14619 }
14620
14621 inline flatbuffers::Offset<Metadata> CreateMetadataDirect(flatbuffers::FlatBufferBuilder &_fbb,
14622                                                           const char *name = nullptr,
14623                                                           uint32_t buffer = 0)
14624 {
14625   auto name__ = name ? _fbb.CreateString(name) : 0;
14626   return circle::CreateMetadata(_fbb, name__, buffer);
14627 }
14628
14629 flatbuffers::Offset<Metadata>
14630 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o,
14631                const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14632
14633 struct TensorMapT : public flatbuffers::NativeTable
14634 {
14635   typedef TensorMap TableType;
14636   std::string name{};
14637   uint32_t tensor_index = 0;
14638 };
14639
14640 struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14641 {
14642   typedef TensorMapT NativeTableType;
14643   typedef TensorMapBuilder Builder;
14644   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14645   {
14646     VT_NAME = 4,
14647     VT_TENSOR_INDEX = 6
14648   };
14649   const flatbuffers::String *name() const
14650   {
14651     return GetPointer<const flatbuffers::String *>(VT_NAME);
14652   }
14653   uint32_t tensor_index() const { return GetField<uint32_t>(VT_TENSOR_INDEX, 0); }
14654   bool Verify(flatbuffers::Verifier &verifier) const
14655   {
14656     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
14657            verifier.VerifyString(name()) && VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX) &&
14658            verifier.EndTable();
14659   }
14660   TensorMapT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14661   void UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14662   static flatbuffers::Offset<TensorMap>
14663   Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o,
14664        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14665 };
14666
14667 struct TensorMapBuilder
14668 {
14669   typedef TensorMap Table;
14670   flatbuffers::FlatBufferBuilder &fbb_;
14671   flatbuffers::uoffset_t start_;
14672   void add_name(flatbuffers::Offset<flatbuffers::String> name)
14673   {
14674     fbb_.AddOffset(TensorMap::VT_NAME, name);
14675   }
14676   void add_tensor_index(uint32_t tensor_index)
14677   {
14678     fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
14679   }
14680   explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14681   {
14682     start_ = fbb_.StartTable();
14683   }
14684   flatbuffers::Offset<TensorMap> Finish()
14685   {
14686     const auto end = fbb_.EndTable(start_);
14687     auto o = flatbuffers::Offset<TensorMap>(end);
14688     return o;
14689   }
14690 };
14691
14692 inline flatbuffers::Offset<TensorMap>
14693 CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb,
14694                 flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t tensor_index = 0)
14695 {
14696   TensorMapBuilder builder_(_fbb);
14697   builder_.add_tensor_index(tensor_index);
14698   builder_.add_name(name);
14699   return builder_.Finish();
14700 }
14701
14702 inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(flatbuffers::FlatBufferBuilder &_fbb,
14703                                                             const char *name = nullptr,
14704                                                             uint32_t tensor_index = 0)
14705 {
14706   auto name__ = name ? _fbb.CreateString(name) : 0;
14707   return circle::CreateTensorMap(_fbb, name__, tensor_index);
14708 }
14709
14710 flatbuffers::Offset<TensorMap>
14711 CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o,
14712                 const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14713
14714 struct SignatureDefT : public flatbuffers::NativeTable
14715 {
14716   typedef SignatureDef TableType;
14717   std::vector<std::unique_ptr<circle::TensorMapT>> inputs{};
14718   std::vector<std::unique_ptr<circle::TensorMapT>> outputs{};
14719   std::string signature_key{};
14720   uint32_t subgraph_index = 0;
14721 };
14722
14723 struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14724 {
14725   typedef SignatureDefT NativeTableType;
14726   typedef SignatureDefBuilder Builder;
14727   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14728   {
14729     VT_INPUTS = 4,
14730     VT_OUTPUTS = 6,
14731     VT_SIGNATURE_KEY = 8,
14732     VT_SUBGRAPH_INDEX = 12
14733   };
14734   const flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>> *inputs() const
14735   {
14736     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>> *>(
14737       VT_INPUTS);
14738   }
14739   const flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>> *outputs() const
14740   {
14741     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>> *>(
14742       VT_OUTPUTS);
14743   }
14744   const flatbuffers::String *signature_key() const
14745   {
14746     return GetPointer<const flatbuffers::String *>(VT_SIGNATURE_KEY);
14747   }
14748   uint32_t subgraph_index() const { return GetField<uint32_t>(VT_SUBGRAPH_INDEX, 0); }
14749   bool Verify(flatbuffers::Verifier &verifier) const
14750   {
14751     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INPUTS) &&
14752            verifier.VerifyVector(inputs()) && verifier.VerifyVectorOfTables(inputs()) &&
14753            VerifyOffset(verifier, VT_OUTPUTS) && verifier.VerifyVector(outputs()) &&
14754            verifier.VerifyVectorOfTables(outputs()) && VerifyOffset(verifier, VT_SIGNATURE_KEY) &&
14755            verifier.VerifyString(signature_key()) &&
14756            VerifyField<uint32_t>(verifier, VT_SUBGRAPH_INDEX) && verifier.EndTable();
14757   }
14758   SignatureDefT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14759   void UnPackTo(SignatureDefT *_o,
14760                 const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14761   static flatbuffers::Offset<SignatureDef>
14762   Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o,
14763        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14764 };
14765
14766 struct SignatureDefBuilder
14767 {
14768   typedef SignatureDef Table;
14769   flatbuffers::FlatBufferBuilder &fbb_;
14770   flatbuffers::uoffset_t start_;
14771   void add_inputs(
14772     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>>> inputs)
14773   {
14774     fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
14775   }
14776   void add_outputs(
14777     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>>> outputs)
14778   {
14779     fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
14780   }
14781   void add_signature_key(flatbuffers::Offset<flatbuffers::String> signature_key)
14782   {
14783     fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key);
14784   }
14785   void add_subgraph_index(uint32_t subgraph_index)
14786   {
14787     fbb_.AddElement<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0);
14788   }
14789   explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14790   {
14791     start_ = fbb_.StartTable();
14792   }
14793   flatbuffers::Offset<SignatureDef> Finish()
14794   {
14795     const auto end = fbb_.EndTable(start_);
14796     auto o = flatbuffers::Offset<SignatureDef>(end);
14797     return o;
14798   }
14799 };
14800
14801 inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
14802   flatbuffers::FlatBufferBuilder &_fbb,
14803   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>>> inputs = 0,
14804   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::TensorMap>>> outputs = 0,
14805   flatbuffers::Offset<flatbuffers::String> signature_key = 0, uint32_t subgraph_index = 0)
14806 {
14807   SignatureDefBuilder builder_(_fbb);
14808   builder_.add_subgraph_index(subgraph_index);
14809   builder_.add_signature_key(signature_key);
14810   builder_.add_outputs(outputs);
14811   builder_.add_inputs(inputs);
14812   return builder_.Finish();
14813 }
14814
14815 inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
14816   flatbuffers::FlatBufferBuilder &_fbb,
14817   const std::vector<flatbuffers::Offset<circle::TensorMap>> *inputs = nullptr,
14818   const std::vector<flatbuffers::Offset<circle::TensorMap>> *outputs = nullptr,
14819   const char *signature_key = nullptr, uint32_t subgraph_index = 0)
14820 {
14821   auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<circle::TensorMap>>(*inputs) : 0;
14822   auto outputs__ =
14823     outputs ? _fbb.CreateVector<flatbuffers::Offset<circle::TensorMap>>(*outputs) : 0;
14824   auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0;
14825   return circle::CreateSignatureDef(_fbb, inputs__, outputs__, signature_key__, subgraph_index);
14826 }
14827
14828 flatbuffers::Offset<SignatureDef>
14829 CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o,
14830                    const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14831
14832 struct ModelT : public flatbuffers::NativeTable
14833 {
14834   typedef Model TableType;
14835   uint32_t version = 0;
14836   std::vector<std::unique_ptr<circle::OperatorCodeT>> operator_codes{};
14837   std::vector<std::unique_ptr<circle::SubGraphT>> subgraphs{};
14838   std::string description{};
14839   std::vector<std::unique_ptr<circle::BufferT>> buffers{};
14840   std::vector<int32_t> metadata_buffer{};
14841   std::vector<std::unique_ptr<circle::MetadataT>> metadata{};
14842   std::vector<std::unique_ptr<circle::SignatureDefT>> signature_defs{};
14843 };
14844
14845 struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
14846 {
14847   typedef ModelT NativeTableType;
14848   typedef ModelBuilder Builder;
14849   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
14850   {
14851     VT_VERSION = 4,
14852     VT_OPERATOR_CODES = 6,
14853     VT_SUBGRAPHS = 8,
14854     VT_DESCRIPTION = 10,
14855     VT_BUFFERS = 12,
14856     VT_METADATA_BUFFER = 14,
14857     VT_METADATA = 16,
14858     VT_SIGNATURE_DEFS = 18
14859   };
14860   uint32_t version() const { return GetField<uint32_t>(VT_VERSION, 0); }
14861   const flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>> *operator_codes() const
14862   {
14863     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>> *>(
14864       VT_OPERATOR_CODES);
14865   }
14866   const flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>> *subgraphs() const
14867   {
14868     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>> *>(
14869       VT_SUBGRAPHS);
14870   }
14871   const flatbuffers::String *description() const
14872   {
14873     return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
14874   }
14875   const flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>> *buffers() const
14876   {
14877     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>> *>(VT_BUFFERS);
14878   }
14879   const flatbuffers::Vector<int32_t> *metadata_buffer() const
14880   {
14881     return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
14882   }
14883   const flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>> *metadata() const
14884   {
14885     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>> *>(
14886       VT_METADATA);
14887   }
14888   const flatbuffers::Vector<flatbuffers::Offset<circle::SignatureDef>> *signature_defs() const
14889   {
14890     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<circle::SignatureDef>> *>(
14891       VT_SIGNATURE_DEFS);
14892   }
14893   bool Verify(flatbuffers::Verifier &verifier) const
14894   {
14895     return VerifyTableStart(verifier) && VerifyField<uint32_t>(verifier, VT_VERSION) &&
14896            VerifyOffset(verifier, VT_OPERATOR_CODES) && verifier.VerifyVector(operator_codes()) &&
14897            verifier.VerifyVectorOfTables(operator_codes()) &&
14898            VerifyOffset(verifier, VT_SUBGRAPHS) && verifier.VerifyVector(subgraphs()) &&
14899            verifier.VerifyVectorOfTables(subgraphs()) && VerifyOffset(verifier, VT_DESCRIPTION) &&
14900            verifier.VerifyString(description()) && VerifyOffset(verifier, VT_BUFFERS) &&
14901            verifier.VerifyVector(buffers()) && verifier.VerifyVectorOfTables(buffers()) &&
14902            VerifyOffset(verifier, VT_METADATA_BUFFER) && verifier.VerifyVector(metadata_buffer()) &&
14903            VerifyOffset(verifier, VT_METADATA) && verifier.VerifyVector(metadata()) &&
14904            verifier.VerifyVectorOfTables(metadata()) && VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
14905            verifier.VerifyVector(signature_defs()) &&
14906            verifier.VerifyVectorOfTables(signature_defs()) && verifier.EndTable();
14907   }
14908   ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14909   void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
14910   static flatbuffers::Offset<Model>
14911   Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o,
14912        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
14913 };
14914
14915 struct ModelBuilder
14916 {
14917   typedef Model Table;
14918   flatbuffers::FlatBufferBuilder &fbb_;
14919   flatbuffers::uoffset_t start_;
14920   void add_version(uint32_t version) { fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0); }
14921   void add_operator_codes(
14922     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>>>
14923       operator_codes)
14924   {
14925     fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
14926   }
14927   void add_subgraphs(
14928     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>>> subgraphs)
14929   {
14930     fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
14931   }
14932   void add_description(flatbuffers::Offset<flatbuffers::String> description)
14933   {
14934     fbb_.AddOffset(Model::VT_DESCRIPTION, description);
14935   }
14936   void
14937   add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>>> buffers)
14938   {
14939     fbb_.AddOffset(Model::VT_BUFFERS, buffers);
14940   }
14941   void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer)
14942   {
14943     fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
14944   }
14945   void add_metadata(
14946     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>>> metadata)
14947   {
14948     fbb_.AddOffset(Model::VT_METADATA, metadata);
14949   }
14950   void add_signature_defs(
14951     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SignatureDef>>>
14952       signature_defs)
14953   {
14954     fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
14955   }
14956   explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
14957   {
14958     start_ = fbb_.StartTable();
14959   }
14960   flatbuffers::Offset<Model> Finish()
14961   {
14962     const auto end = fbb_.EndTable(start_);
14963     auto o = flatbuffers::Offset<Model>(end);
14964     return o;
14965   }
14966 };
14967
14968 inline flatbuffers::Offset<Model> CreateModel(
14969   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
14970   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::OperatorCode>>>
14971     operator_codes = 0,
14972   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>>> subgraphs = 0,
14973   flatbuffers::Offset<flatbuffers::String> description = 0,
14974   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Buffer>>> buffers = 0,
14975   flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
14976   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::Metadata>>> metadata = 0,
14977   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::SignatureDef>>>
14978     signature_defs = 0)
14979 {
14980   ModelBuilder builder_(_fbb);
14981   builder_.add_signature_defs(signature_defs);
14982   builder_.add_metadata(metadata);
14983   builder_.add_metadata_buffer(metadata_buffer);
14984   builder_.add_buffers(buffers);
14985   builder_.add_description(description);
14986   builder_.add_subgraphs(subgraphs);
14987   builder_.add_operator_codes(operator_codes);
14988   builder_.add_version(version);
14989   return builder_.Finish();
14990 }
14991
14992 inline flatbuffers::Offset<Model> CreateModelDirect(
14993   flatbuffers::FlatBufferBuilder &_fbb, uint32_t version = 0,
14994   const std::vector<flatbuffers::Offset<circle::OperatorCode>> *operator_codes = nullptr,
14995   const std::vector<flatbuffers::Offset<circle::SubGraph>> *subgraphs = nullptr,
14996   const char *description = nullptr,
14997   const std::vector<flatbuffers::Offset<circle::Buffer>> *buffers = nullptr,
14998   const std::vector<int32_t> *metadata_buffer = nullptr,
14999   const std::vector<flatbuffers::Offset<circle::Metadata>> *metadata = nullptr,
15000   const std::vector<flatbuffers::Offset<circle::SignatureDef>> *signature_defs = nullptr)
15001 {
15002   auto operator_codes__ =
15003     operator_codes ? _fbb.CreateVector<flatbuffers::Offset<circle::OperatorCode>>(*operator_codes)
15004                    : 0;
15005   auto subgraphs__ =
15006     subgraphs ? _fbb.CreateVector<flatbuffers::Offset<circle::SubGraph>>(*subgraphs) : 0;
15007   auto description__ = description ? _fbb.CreateString(description) : 0;
15008   auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<circle::Buffer>>(*buffers) : 0;
15009   auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
15010   auto metadata__ =
15011     metadata ? _fbb.CreateVector<flatbuffers::Offset<circle::Metadata>>(*metadata) : 0;
15012   auto signature_defs__ =
15013     signature_defs ? _fbb.CreateVector<flatbuffers::Offset<circle::SignatureDef>>(*signature_defs)
15014                    : 0;
15015   return circle::CreateModel(_fbb, version, operator_codes__, subgraphs__, description__, buffers__,
15016                              metadata_buffer__, metadata__, signature_defs__);
15017 }
15018
15019 flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o,
15020                                        const flatbuffers::rehasher_function_t *_rehasher = nullptr);
15021
15022 inline CustomQuantizationT *
15023 CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15024 {
15025   auto _o = std::unique_ptr<CustomQuantizationT>(new CustomQuantizationT());
15026   UnPackTo(_o.get(), _resolver);
15027   return _o.release();
15028 }
15029
15030 inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o,
15031                                          const flatbuffers::resolver_function_t *_resolver) const
15032 {
15033   (void)_o;
15034   (void)_resolver;
15035   {
15036     auto _e = custom();
15037     if (_e)
15038     {
15039       _o->custom.resize(_e->size());
15040       std::copy(_e->begin(), _e->end(), _o->custom.begin());
15041     }
15042   }
15043 }
15044
15045 inline flatbuffers::Offset<CustomQuantization>
15046 CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o,
15047                          const flatbuffers::rehasher_function_t *_rehasher)
15048 {
15049   return CreateCustomQuantization(_fbb, _o, _rehasher);
15050 }
15051
15052 inline flatbuffers::Offset<CustomQuantization>
15053 CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o,
15054                          const flatbuffers::rehasher_function_t *_rehasher)
15055 {
15056   (void)_rehasher;
15057   (void)_o;
15058   struct _VectorArgs
15059   {
15060     flatbuffers::FlatBufferBuilder *__fbb;
15061     const CustomQuantizationT *__o;
15062     const flatbuffers::rehasher_function_t *__rehasher;
15063   } _va = {&_fbb, _o, _rehasher};
15064   (void)_va;
15065   _fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), 16);
15066   auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0;
15067   return circle::CreateCustomQuantization(_fbb, _custom);
15068 }
15069
15070 inline QuantizationParametersT *
15071 QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15072 {
15073   auto _o = std::unique_ptr<QuantizationParametersT>(new QuantizationParametersT());
15074   UnPackTo(_o.get(), _resolver);
15075   return _o.release();
15076 }
15077
15078 inline void
15079 QuantizationParameters::UnPackTo(QuantizationParametersT *_o,
15080                                  const flatbuffers::resolver_function_t *_resolver) const
15081 {
15082   (void)_o;
15083   (void)_resolver;
15084   {
15085     auto _e = min();
15086     if (_e)
15087     {
15088       _o->min.resize(_e->size());
15089       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15090       {
15091         _o->min[_i] = _e->Get(_i);
15092       }
15093     }
15094   }
15095   {
15096     auto _e = max();
15097     if (_e)
15098     {
15099       _o->max.resize(_e->size());
15100       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15101       {
15102         _o->max[_i] = _e->Get(_i);
15103       }
15104     }
15105   }
15106   {
15107     auto _e = scale();
15108     if (_e)
15109     {
15110       _o->scale.resize(_e->size());
15111       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15112       {
15113         _o->scale[_i] = _e->Get(_i);
15114       }
15115     }
15116   }
15117   {
15118     auto _e = zero_point();
15119     if (_e)
15120     {
15121       _o->zero_point.resize(_e->size());
15122       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15123       {
15124         _o->zero_point[_i] = _e->Get(_i);
15125       }
15126     }
15127   }
15128   {
15129     auto _e = details_type();
15130     _o->details.type = _e;
15131   }
15132   {
15133     auto _e = details();
15134     if (_e)
15135       _o->details.value = circle::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver);
15136   }
15137   {
15138     auto _e = quantized_dimension();
15139     _o->quantized_dimension = _e;
15140   }
15141 }
15142
15143 inline flatbuffers::Offset<QuantizationParameters>
15144 QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb,
15145                              const QuantizationParametersT *_o,
15146                              const flatbuffers::rehasher_function_t *_rehasher)
15147 {
15148   return CreateQuantizationParameters(_fbb, _o, _rehasher);
15149 }
15150
15151 inline flatbuffers::Offset<QuantizationParameters>
15152 CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb,
15153                              const QuantizationParametersT *_o,
15154                              const flatbuffers::rehasher_function_t *_rehasher)
15155 {
15156   (void)_rehasher;
15157   (void)_o;
15158   struct _VectorArgs
15159   {
15160     flatbuffers::FlatBufferBuilder *__fbb;
15161     const QuantizationParametersT *__o;
15162     const flatbuffers::rehasher_function_t *__rehasher;
15163   } _va = {&_fbb, _o, _rehasher};
15164   (void)_va;
15165   auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0;
15166   auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0;
15167   auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0;
15168   auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
15169   auto _details_type = _o->details.type;
15170   auto _details = _o->details.Pack(_fbb);
15171   auto _quantized_dimension = _o->quantized_dimension;
15172   return circle::CreateQuantizationParameters(_fbb, _min, _max, _scale, _zero_point, _details_type,
15173                                               _details, _quantized_dimension);
15174 }
15175
15176 inline Int32VectorT *Int32Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15177 {
15178   auto _o = std::unique_ptr<Int32VectorT>(new Int32VectorT());
15179   UnPackTo(_o.get(), _resolver);
15180   return _o.release();
15181 }
15182
15183 inline void Int32Vector::UnPackTo(Int32VectorT *_o,
15184                                   const flatbuffers::resolver_function_t *_resolver) const
15185 {
15186   (void)_o;
15187   (void)_resolver;
15188   {
15189     auto _e = values();
15190     if (_e)
15191     {
15192       _o->values.resize(_e->size());
15193       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15194       {
15195         _o->values[_i] = _e->Get(_i);
15196       }
15197     }
15198   }
15199 }
15200
15201 inline flatbuffers::Offset<Int32Vector>
15202 Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o,
15203                   const flatbuffers::rehasher_function_t *_rehasher)
15204 {
15205   return CreateInt32Vector(_fbb, _o, _rehasher);
15206 }
15207
15208 inline flatbuffers::Offset<Int32Vector>
15209 CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o,
15210                   const flatbuffers::rehasher_function_t *_rehasher)
15211 {
15212   (void)_rehasher;
15213   (void)_o;
15214   struct _VectorArgs
15215   {
15216     flatbuffers::FlatBufferBuilder *__fbb;
15217     const Int32VectorT *__o;
15218     const flatbuffers::rehasher_function_t *__rehasher;
15219   } _va = {&_fbb, _o, _rehasher};
15220   (void)_va;
15221   auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
15222   return circle::CreateInt32Vector(_fbb, _values);
15223 }
15224
15225 inline Uint16VectorT *Uint16Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15226 {
15227   auto _o = std::unique_ptr<Uint16VectorT>(new Uint16VectorT());
15228   UnPackTo(_o.get(), _resolver);
15229   return _o.release();
15230 }
15231
15232 inline void Uint16Vector::UnPackTo(Uint16VectorT *_o,
15233                                    const flatbuffers::resolver_function_t *_resolver) const
15234 {
15235   (void)_o;
15236   (void)_resolver;
15237   {
15238     auto _e = values();
15239     if (_e)
15240     {
15241       _o->values.resize(_e->size());
15242       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15243       {
15244         _o->values[_i] = _e->Get(_i);
15245       }
15246     }
15247   }
15248 }
15249
15250 inline flatbuffers::Offset<Uint16Vector>
15251 Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o,
15252                    const flatbuffers::rehasher_function_t *_rehasher)
15253 {
15254   return CreateUint16Vector(_fbb, _o, _rehasher);
15255 }
15256
15257 inline flatbuffers::Offset<Uint16Vector>
15258 CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o,
15259                    const flatbuffers::rehasher_function_t *_rehasher)
15260 {
15261   (void)_rehasher;
15262   (void)_o;
15263   struct _VectorArgs
15264   {
15265     flatbuffers::FlatBufferBuilder *__fbb;
15266     const Uint16VectorT *__o;
15267     const flatbuffers::rehasher_function_t *__rehasher;
15268   } _va = {&_fbb, _o, _rehasher};
15269   (void)_va;
15270   _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), 4);
15271   auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
15272   return circle::CreateUint16Vector(_fbb, _values);
15273 }
15274
15275 inline Uint8VectorT *Uint8Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15276 {
15277   auto _o = std::unique_ptr<Uint8VectorT>(new Uint8VectorT());
15278   UnPackTo(_o.get(), _resolver);
15279   return _o.release();
15280 }
15281
15282 inline void Uint8Vector::UnPackTo(Uint8VectorT *_o,
15283                                   const flatbuffers::resolver_function_t *_resolver) const
15284 {
15285   (void)_o;
15286   (void)_resolver;
15287   {
15288     auto _e = values();
15289     if (_e)
15290     {
15291       _o->values.resize(_e->size());
15292       std::copy(_e->begin(), _e->end(), _o->values.begin());
15293     }
15294   }
15295 }
15296
15297 inline flatbuffers::Offset<Uint8Vector>
15298 Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o,
15299                   const flatbuffers::rehasher_function_t *_rehasher)
15300 {
15301   return CreateUint8Vector(_fbb, _o, _rehasher);
15302 }
15303
15304 inline flatbuffers::Offset<Uint8Vector>
15305 CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o,
15306                   const flatbuffers::rehasher_function_t *_rehasher)
15307 {
15308   (void)_rehasher;
15309   (void)_o;
15310   struct _VectorArgs
15311   {
15312     flatbuffers::FlatBufferBuilder *__fbb;
15313     const Uint8VectorT *__o;
15314     const flatbuffers::rehasher_function_t *__rehasher;
15315   } _va = {&_fbb, _o, _rehasher};
15316   (void)_va;
15317   _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), 4);
15318   auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
15319   return circle::CreateUint8Vector(_fbb, _values);
15320 }
15321
15322 inline DimensionMetadataT *
15323 DimensionMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15324 {
15325   auto _o = std::unique_ptr<DimensionMetadataT>(new DimensionMetadataT());
15326   UnPackTo(_o.get(), _resolver);
15327   return _o.release();
15328 }
15329
15330 inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o,
15331                                         const flatbuffers::resolver_function_t *_resolver) const
15332 {
15333   (void)_o;
15334   (void)_resolver;
15335   {
15336     auto _e = format();
15337     _o->format = _e;
15338   }
15339   {
15340     auto _e = dense_size();
15341     _o->dense_size = _e;
15342   }
15343   {
15344     auto _e = array_segments_type();
15345     _o->array_segments.type = _e;
15346   }
15347   {
15348     auto _e = array_segments();
15349     if (_e)
15350       _o->array_segments.value =
15351         circle::SparseIndexVectorUnion::UnPack(_e, array_segments_type(), _resolver);
15352   }
15353   {
15354     auto _e = array_indices_type();
15355     _o->array_indices.type = _e;
15356   }
15357   {
15358     auto _e = array_indices();
15359     if (_e)
15360       _o->array_indices.value =
15361         circle::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver);
15362   }
15363 }
15364
15365 inline flatbuffers::Offset<DimensionMetadata>
15366 DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o,
15367                         const flatbuffers::rehasher_function_t *_rehasher)
15368 {
15369   return CreateDimensionMetadata(_fbb, _o, _rehasher);
15370 }
15371
15372 inline flatbuffers::Offset<DimensionMetadata>
15373 CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o,
15374                         const flatbuffers::rehasher_function_t *_rehasher)
15375 {
15376   (void)_rehasher;
15377   (void)_o;
15378   struct _VectorArgs
15379   {
15380     flatbuffers::FlatBufferBuilder *__fbb;
15381     const DimensionMetadataT *__o;
15382     const flatbuffers::rehasher_function_t *__rehasher;
15383   } _va = {&_fbb, _o, _rehasher};
15384   (void)_va;
15385   auto _format = _o->format;
15386   auto _dense_size = _o->dense_size;
15387   auto _array_segments_type = _o->array_segments.type;
15388   auto _array_segments = _o->array_segments.Pack(_fbb);
15389   auto _array_indices_type = _o->array_indices.type;
15390   auto _array_indices = _o->array_indices.Pack(_fbb);
15391   return circle::CreateDimensionMetadata(_fbb, _format, _dense_size, _array_segments_type,
15392                                          _array_segments, _array_indices_type, _array_indices);
15393 }
15394
15395 inline SparsityParametersT *
15396 SparsityParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15397 {
15398   auto _o = std::unique_ptr<SparsityParametersT>(new SparsityParametersT());
15399   UnPackTo(_o.get(), _resolver);
15400   return _o.release();
15401 }
15402
15403 inline void SparsityParameters::UnPackTo(SparsityParametersT *_o,
15404                                          const flatbuffers::resolver_function_t *_resolver) const
15405 {
15406   (void)_o;
15407   (void)_resolver;
15408   {
15409     auto _e = traversal_order();
15410     if (_e)
15411     {
15412       _o->traversal_order.resize(_e->size());
15413       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15414       {
15415         _o->traversal_order[_i] = _e->Get(_i);
15416       }
15417     }
15418   }
15419   {
15420     auto _e = block_map();
15421     if (_e)
15422     {
15423       _o->block_map.resize(_e->size());
15424       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15425       {
15426         _o->block_map[_i] = _e->Get(_i);
15427       }
15428     }
15429   }
15430   {
15431     auto _e = dim_metadata();
15432     if (_e)
15433     {
15434       _o->dim_metadata.resize(_e->size());
15435       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15436       {
15437         _o->dim_metadata[_i] =
15438           std::unique_ptr<circle::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver));
15439       }
15440     }
15441   }
15442 }
15443
15444 inline flatbuffers::Offset<SparsityParameters>
15445 SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o,
15446                          const flatbuffers::rehasher_function_t *_rehasher)
15447 {
15448   return CreateSparsityParameters(_fbb, _o, _rehasher);
15449 }
15450
15451 inline flatbuffers::Offset<SparsityParameters>
15452 CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o,
15453                          const flatbuffers::rehasher_function_t *_rehasher)
15454 {
15455   (void)_rehasher;
15456   (void)_o;
15457   struct _VectorArgs
15458   {
15459     flatbuffers::FlatBufferBuilder *__fbb;
15460     const SparsityParametersT *__o;
15461     const flatbuffers::rehasher_function_t *__rehasher;
15462   } _va = {&_fbb, _o, _rehasher};
15463   (void)_va;
15464   auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : 0;
15465   auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : 0;
15466   auto _dim_metadata = _o->dim_metadata.size()
15467                          ? _fbb.CreateVector<flatbuffers::Offset<circle::DimensionMetadata>>(
15468                              _o->dim_metadata.size(),
15469                              [](size_t i, _VectorArgs *__va) {
15470                                return CreateDimensionMetadata(
15471                                  *__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher);
15472                              },
15473                              &_va)
15474                          : 0;
15475   return circle::CreateSparsityParameters(_fbb, _traversal_order, _block_map, _dim_metadata);
15476 }
15477
15478 inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15479 {
15480   auto _o = std::unique_ptr<TensorT>(new TensorT());
15481   UnPackTo(_o.get(), _resolver);
15482   return _o.release();
15483 }
15484
15485 inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const
15486 {
15487   (void)_o;
15488   (void)_resolver;
15489   {
15490     auto _e = shape();
15491     if (_e)
15492     {
15493       _o->shape.resize(_e->size());
15494       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15495       {
15496         _o->shape[_i] = _e->Get(_i);
15497       }
15498     }
15499   }
15500   {
15501     auto _e = type();
15502     _o->type = _e;
15503   }
15504   {
15505     auto _e = buffer();
15506     _o->buffer = _e;
15507   }
15508   {
15509     auto _e = name();
15510     if (_e)
15511       _o->name = _e->str();
15512   }
15513   {
15514     auto _e = quantization();
15515     if (_e)
15516       _o->quantization = std::unique_ptr<circle::QuantizationParametersT>(_e->UnPack(_resolver));
15517   }
15518   {
15519     auto _e = is_variable();
15520     _o->is_variable = _e;
15521   }
15522   {
15523     auto _e = sparsity();
15524     if (_e)
15525       _o->sparsity = std::unique_ptr<circle::SparsityParametersT>(_e->UnPack(_resolver));
15526   }
15527   {
15528     auto _e = shape_signature();
15529     if (_e)
15530     {
15531       _o->shape_signature.resize(_e->size());
15532       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15533       {
15534         _o->shape_signature[_i] = _e->Get(_i);
15535       }
15536     }
15537   }
15538 }
15539
15540 inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb,
15541                                                 const TensorT *_o,
15542                                                 const flatbuffers::rehasher_function_t *_rehasher)
15543 {
15544   return CreateTensor(_fbb, _o, _rehasher);
15545 }
15546
15547 inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb,
15548                                                 const TensorT *_o,
15549                                                 const flatbuffers::rehasher_function_t *_rehasher)
15550 {
15551   (void)_rehasher;
15552   (void)_o;
15553   struct _VectorArgs
15554   {
15555     flatbuffers::FlatBufferBuilder *__fbb;
15556     const TensorT *__o;
15557     const flatbuffers::rehasher_function_t *__rehasher;
15558   } _va = {&_fbb, _o, _rehasher};
15559   (void)_va;
15560   auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0;
15561   auto _type = _o->type;
15562   auto _buffer = _o->buffer;
15563   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
15564   auto _quantization =
15565     _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0;
15566   auto _is_variable = _o->is_variable;
15567   auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : 0;
15568   auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : 0;
15569   return circle::CreateTensor(_fbb, _shape, _type, _buffer, _name, _quantization, _is_variable,
15570                               _sparsity, _shape_signature);
15571 }
15572
15573 inline Conv2DOptionsT *
15574 Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15575 {
15576   auto _o = std::unique_ptr<Conv2DOptionsT>(new Conv2DOptionsT());
15577   UnPackTo(_o.get(), _resolver);
15578   return _o.release();
15579 }
15580
15581 inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o,
15582                                     const flatbuffers::resolver_function_t *_resolver) const
15583 {
15584   (void)_o;
15585   (void)_resolver;
15586   {
15587     auto _e = padding();
15588     _o->padding = _e;
15589   }
15590   {
15591     auto _e = stride_w();
15592     _o->stride_w = _e;
15593   }
15594   {
15595     auto _e = stride_h();
15596     _o->stride_h = _e;
15597   }
15598   {
15599     auto _e = fused_activation_function();
15600     _o->fused_activation_function = _e;
15601   }
15602   {
15603     auto _e = dilation_w_factor();
15604     _o->dilation_w_factor = _e;
15605   }
15606   {
15607     auto _e = dilation_h_factor();
15608     _o->dilation_h_factor = _e;
15609   }
15610 }
15611
15612 inline flatbuffers::Offset<Conv2DOptions>
15613 Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o,
15614                     const flatbuffers::rehasher_function_t *_rehasher)
15615 {
15616   return CreateConv2DOptions(_fbb, _o, _rehasher);
15617 }
15618
15619 inline flatbuffers::Offset<Conv2DOptions>
15620 CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o,
15621                     const flatbuffers::rehasher_function_t *_rehasher)
15622 {
15623   (void)_rehasher;
15624   (void)_o;
15625   struct _VectorArgs
15626   {
15627     flatbuffers::FlatBufferBuilder *__fbb;
15628     const Conv2DOptionsT *__o;
15629     const flatbuffers::rehasher_function_t *__rehasher;
15630   } _va = {&_fbb, _o, _rehasher};
15631   (void)_va;
15632   auto _padding = _o->padding;
15633   auto _stride_w = _o->stride_w;
15634   auto _stride_h = _o->stride_h;
15635   auto _fused_activation_function = _o->fused_activation_function;
15636   auto _dilation_w_factor = _o->dilation_w_factor;
15637   auto _dilation_h_factor = _o->dilation_h_factor;
15638   return circle::CreateConv2DOptions(_fbb, _padding, _stride_w, _stride_h,
15639                                      _fused_activation_function, _dilation_w_factor,
15640                                      _dilation_h_factor);
15641 }
15642
15643 inline Conv3DOptionsT *
15644 Conv3DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15645 {
15646   auto _o = std::unique_ptr<Conv3DOptionsT>(new Conv3DOptionsT());
15647   UnPackTo(_o.get(), _resolver);
15648   return _o.release();
15649 }
15650
15651 inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o,
15652                                     const flatbuffers::resolver_function_t *_resolver) const
15653 {
15654   (void)_o;
15655   (void)_resolver;
15656   {
15657     auto _e = padding();
15658     _o->padding = _e;
15659   }
15660   {
15661     auto _e = stride_d();
15662     _o->stride_d = _e;
15663   }
15664   {
15665     auto _e = stride_w();
15666     _o->stride_w = _e;
15667   }
15668   {
15669     auto _e = stride_h();
15670     _o->stride_h = _e;
15671   }
15672   {
15673     auto _e = fused_activation_function();
15674     _o->fused_activation_function = _e;
15675   }
15676   {
15677     auto _e = dilation_d_factor();
15678     _o->dilation_d_factor = _e;
15679   }
15680   {
15681     auto _e = dilation_w_factor();
15682     _o->dilation_w_factor = _e;
15683   }
15684   {
15685     auto _e = dilation_h_factor();
15686     _o->dilation_h_factor = _e;
15687   }
15688 }
15689
15690 inline flatbuffers::Offset<Conv3DOptions>
15691 Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o,
15692                     const flatbuffers::rehasher_function_t *_rehasher)
15693 {
15694   return CreateConv3DOptions(_fbb, _o, _rehasher);
15695 }
15696
15697 inline flatbuffers::Offset<Conv3DOptions>
15698 CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o,
15699                     const flatbuffers::rehasher_function_t *_rehasher)
15700 {
15701   (void)_rehasher;
15702   (void)_o;
15703   struct _VectorArgs
15704   {
15705     flatbuffers::FlatBufferBuilder *__fbb;
15706     const Conv3DOptionsT *__o;
15707     const flatbuffers::rehasher_function_t *__rehasher;
15708   } _va = {&_fbb, _o, _rehasher};
15709   (void)_va;
15710   auto _padding = _o->padding;
15711   auto _stride_d = _o->stride_d;
15712   auto _stride_w = _o->stride_w;
15713   auto _stride_h = _o->stride_h;
15714   auto _fused_activation_function = _o->fused_activation_function;
15715   auto _dilation_d_factor = _o->dilation_d_factor;
15716   auto _dilation_w_factor = _o->dilation_w_factor;
15717   auto _dilation_h_factor = _o->dilation_h_factor;
15718   return circle::CreateConv3DOptions(_fbb, _padding, _stride_d, _stride_w, _stride_h,
15719                                      _fused_activation_function, _dilation_d_factor,
15720                                      _dilation_w_factor, _dilation_h_factor);
15721 }
15722
15723 inline Pool2DOptionsT *
15724 Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15725 {
15726   auto _o = std::unique_ptr<Pool2DOptionsT>(new Pool2DOptionsT());
15727   UnPackTo(_o.get(), _resolver);
15728   return _o.release();
15729 }
15730
15731 inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o,
15732                                     const flatbuffers::resolver_function_t *_resolver) const
15733 {
15734   (void)_o;
15735   (void)_resolver;
15736   {
15737     auto _e = padding();
15738     _o->padding = _e;
15739   }
15740   {
15741     auto _e = stride_w();
15742     _o->stride_w = _e;
15743   }
15744   {
15745     auto _e = stride_h();
15746     _o->stride_h = _e;
15747   }
15748   {
15749     auto _e = filter_width();
15750     _o->filter_width = _e;
15751   }
15752   {
15753     auto _e = filter_height();
15754     _o->filter_height = _e;
15755   }
15756   {
15757     auto _e = fused_activation_function();
15758     _o->fused_activation_function = _e;
15759   }
15760 }
15761
15762 inline flatbuffers::Offset<Pool2DOptions>
15763 Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o,
15764                     const flatbuffers::rehasher_function_t *_rehasher)
15765 {
15766   return CreatePool2DOptions(_fbb, _o, _rehasher);
15767 }
15768
15769 inline flatbuffers::Offset<Pool2DOptions>
15770 CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o,
15771                     const flatbuffers::rehasher_function_t *_rehasher)
15772 {
15773   (void)_rehasher;
15774   (void)_o;
15775   struct _VectorArgs
15776   {
15777     flatbuffers::FlatBufferBuilder *__fbb;
15778     const Pool2DOptionsT *__o;
15779     const flatbuffers::rehasher_function_t *__rehasher;
15780   } _va = {&_fbb, _o, _rehasher};
15781   (void)_va;
15782   auto _padding = _o->padding;
15783   auto _stride_w = _o->stride_w;
15784   auto _stride_h = _o->stride_h;
15785   auto _filter_width = _o->filter_width;
15786   auto _filter_height = _o->filter_height;
15787   auto _fused_activation_function = _o->fused_activation_function;
15788   return circle::CreatePool2DOptions(_fbb, _padding, _stride_w, _stride_h, _filter_width,
15789                                      _filter_height, _fused_activation_function);
15790 }
15791
15792 inline DepthwiseConv2DOptionsT *
15793 DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15794 {
15795   auto _o = std::unique_ptr<DepthwiseConv2DOptionsT>(new DepthwiseConv2DOptionsT());
15796   UnPackTo(_o.get(), _resolver);
15797   return _o.release();
15798 }
15799
15800 inline void
15801 DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o,
15802                                  const flatbuffers::resolver_function_t *_resolver) const
15803 {
15804   (void)_o;
15805   (void)_resolver;
15806   {
15807     auto _e = padding();
15808     _o->padding = _e;
15809   }
15810   {
15811     auto _e = stride_w();
15812     _o->stride_w = _e;
15813   }
15814   {
15815     auto _e = stride_h();
15816     _o->stride_h = _e;
15817   }
15818   {
15819     auto _e = depth_multiplier();
15820     _o->depth_multiplier = _e;
15821   }
15822   {
15823     auto _e = fused_activation_function();
15824     _o->fused_activation_function = _e;
15825   }
15826   {
15827     auto _e = dilation_w_factor();
15828     _o->dilation_w_factor = _e;
15829   }
15830   {
15831     auto _e = dilation_h_factor();
15832     _o->dilation_h_factor = _e;
15833   }
15834 }
15835
15836 inline flatbuffers::Offset<DepthwiseConv2DOptions>
15837 DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
15838                              const DepthwiseConv2DOptionsT *_o,
15839                              const flatbuffers::rehasher_function_t *_rehasher)
15840 {
15841   return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
15842 }
15843
15844 inline flatbuffers::Offset<DepthwiseConv2DOptions>
15845 CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb,
15846                              const DepthwiseConv2DOptionsT *_o,
15847                              const flatbuffers::rehasher_function_t *_rehasher)
15848 {
15849   (void)_rehasher;
15850   (void)_o;
15851   struct _VectorArgs
15852   {
15853     flatbuffers::FlatBufferBuilder *__fbb;
15854     const DepthwiseConv2DOptionsT *__o;
15855     const flatbuffers::rehasher_function_t *__rehasher;
15856   } _va = {&_fbb, _o, _rehasher};
15857   (void)_va;
15858   auto _padding = _o->padding;
15859   auto _stride_w = _o->stride_w;
15860   auto _stride_h = _o->stride_h;
15861   auto _depth_multiplier = _o->depth_multiplier;
15862   auto _fused_activation_function = _o->fused_activation_function;
15863   auto _dilation_w_factor = _o->dilation_w_factor;
15864   auto _dilation_h_factor = _o->dilation_h_factor;
15865   return circle::CreateDepthwiseConv2DOptions(_fbb, _padding, _stride_w, _stride_h,
15866                                               _depth_multiplier, _fused_activation_function,
15867                                               _dilation_w_factor, _dilation_h_factor);
15868 }
15869
15870 inline ConcatEmbeddingsOptionsT *
15871 ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15872 {
15873   auto _o = std::unique_ptr<ConcatEmbeddingsOptionsT>(new ConcatEmbeddingsOptionsT());
15874   UnPackTo(_o.get(), _resolver);
15875   return _o.release();
15876 }
15877
15878 inline void
15879 ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o,
15880                                   const flatbuffers::resolver_function_t *_resolver) const
15881 {
15882   (void)_o;
15883   (void)_resolver;
15884   {
15885     auto _e = num_channels();
15886     _o->num_channels = _e;
15887   }
15888   {
15889     auto _e = num_columns_per_channel();
15890     if (_e)
15891     {
15892       _o->num_columns_per_channel.resize(_e->size());
15893       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15894       {
15895         _o->num_columns_per_channel[_i] = _e->Get(_i);
15896       }
15897     }
15898   }
15899   {
15900     auto _e = embedding_dim_per_channel();
15901     if (_e)
15902     {
15903       _o->embedding_dim_per_channel.resize(_e->size());
15904       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
15905       {
15906         _o->embedding_dim_per_channel[_i] = _e->Get(_i);
15907       }
15908     }
15909   }
15910 }
15911
15912 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
15913 ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
15914                               const ConcatEmbeddingsOptionsT *_o,
15915                               const flatbuffers::rehasher_function_t *_rehasher)
15916 {
15917   return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
15918 }
15919
15920 inline flatbuffers::Offset<ConcatEmbeddingsOptions>
15921 CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb,
15922                               const ConcatEmbeddingsOptionsT *_o,
15923                               const flatbuffers::rehasher_function_t *_rehasher)
15924 {
15925   (void)_rehasher;
15926   (void)_o;
15927   struct _VectorArgs
15928   {
15929     flatbuffers::FlatBufferBuilder *__fbb;
15930     const ConcatEmbeddingsOptionsT *__o;
15931     const flatbuffers::rehasher_function_t *__rehasher;
15932   } _va = {&_fbb, _o, _rehasher};
15933   (void)_va;
15934   auto _num_channels = _o->num_channels;
15935   auto _num_columns_per_channel =
15936     _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0;
15937   auto _embedding_dim_per_channel =
15938     _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0;
15939   return circle::CreateConcatEmbeddingsOptions(_fbb, _num_channels, _num_columns_per_channel,
15940                                                _embedding_dim_per_channel);
15941 }
15942
15943 inline LSHProjectionOptionsT *
15944 LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15945 {
15946   auto _o = std::unique_ptr<LSHProjectionOptionsT>(new LSHProjectionOptionsT());
15947   UnPackTo(_o.get(), _resolver);
15948   return _o.release();
15949 }
15950
15951 inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o,
15952                                            const flatbuffers::resolver_function_t *_resolver) const
15953 {
15954   (void)_o;
15955   (void)_resolver;
15956   {
15957     auto _e = type();
15958     _o->type = _e;
15959   }
15960 }
15961
15962 inline flatbuffers::Offset<LSHProjectionOptions>
15963 LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o,
15964                            const flatbuffers::rehasher_function_t *_rehasher)
15965 {
15966   return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
15967 }
15968
15969 inline flatbuffers::Offset<LSHProjectionOptions>
15970 CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o,
15971                            const flatbuffers::rehasher_function_t *_rehasher)
15972 {
15973   (void)_rehasher;
15974   (void)_o;
15975   struct _VectorArgs
15976   {
15977     flatbuffers::FlatBufferBuilder *__fbb;
15978     const LSHProjectionOptionsT *__o;
15979     const flatbuffers::rehasher_function_t *__rehasher;
15980   } _va = {&_fbb, _o, _rehasher};
15981   (void)_va;
15982   auto _type = _o->type;
15983   return circle::CreateLSHProjectionOptions(_fbb, _type);
15984 }
15985
15986 inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
15987 {
15988   auto _o = std::unique_ptr<SVDFOptionsT>(new SVDFOptionsT());
15989   UnPackTo(_o.get(), _resolver);
15990   return _o.release();
15991 }
15992
15993 inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o,
15994                                   const flatbuffers::resolver_function_t *_resolver) const
15995 {
15996   (void)_o;
15997   (void)_resolver;
15998   {
15999     auto _e = rank();
16000     _o->rank = _e;
16001   }
16002   {
16003     auto _e = fused_activation_function();
16004     _o->fused_activation_function = _e;
16005   }
16006   {
16007     auto _e = asymmetric_quantize_inputs();
16008     _o->asymmetric_quantize_inputs = _e;
16009   }
16010 }
16011
16012 inline flatbuffers::Offset<SVDFOptions>
16013 SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o,
16014                   const flatbuffers::rehasher_function_t *_rehasher)
16015 {
16016   return CreateSVDFOptions(_fbb, _o, _rehasher);
16017 }
16018
16019 inline flatbuffers::Offset<SVDFOptions>
16020 CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o,
16021                   const flatbuffers::rehasher_function_t *_rehasher)
16022 {
16023   (void)_rehasher;
16024   (void)_o;
16025   struct _VectorArgs
16026   {
16027     flatbuffers::FlatBufferBuilder *__fbb;
16028     const SVDFOptionsT *__o;
16029     const flatbuffers::rehasher_function_t *__rehasher;
16030   } _va = {&_fbb, _o, _rehasher};
16031   (void)_va;
16032   auto _rank = _o->rank;
16033   auto _fused_activation_function = _o->fused_activation_function;
16034   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16035   return circle::CreateSVDFOptions(_fbb, _rank, _fused_activation_function,
16036                                    _asymmetric_quantize_inputs);
16037 }
16038
16039 inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16040 {
16041   auto _o = std::unique_ptr<RNNOptionsT>(new RNNOptionsT());
16042   UnPackTo(_o.get(), _resolver);
16043   return _o.release();
16044 }
16045
16046 inline void RNNOptions::UnPackTo(RNNOptionsT *_o,
16047                                  const flatbuffers::resolver_function_t *_resolver) const
16048 {
16049   (void)_o;
16050   (void)_resolver;
16051   {
16052     auto _e = fused_activation_function();
16053     _o->fused_activation_function = _e;
16054   }
16055   {
16056     auto _e = asymmetric_quantize_inputs();
16057     _o->asymmetric_quantize_inputs = _e;
16058   }
16059 }
16060
16061 inline flatbuffers::Offset<RNNOptions>
16062 RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o,
16063                  const flatbuffers::rehasher_function_t *_rehasher)
16064 {
16065   return CreateRNNOptions(_fbb, _o, _rehasher);
16066 }
16067
16068 inline flatbuffers::Offset<RNNOptions>
16069 CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o,
16070                  const flatbuffers::rehasher_function_t *_rehasher)
16071 {
16072   (void)_rehasher;
16073   (void)_o;
16074   struct _VectorArgs
16075   {
16076     flatbuffers::FlatBufferBuilder *__fbb;
16077     const RNNOptionsT *__o;
16078     const flatbuffers::rehasher_function_t *__rehasher;
16079   } _va = {&_fbb, _o, _rehasher};
16080   (void)_va;
16081   auto _fused_activation_function = _o->fused_activation_function;
16082   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16083   return circle::CreateRNNOptions(_fbb, _fused_activation_function, _asymmetric_quantize_inputs);
16084 }
16085
16086 inline SequenceRNNOptionsT *
16087 SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16088 {
16089   auto _o = std::unique_ptr<SequenceRNNOptionsT>(new SequenceRNNOptionsT());
16090   UnPackTo(_o.get(), _resolver);
16091   return _o.release();
16092 }
16093
16094 inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o,
16095                                          const flatbuffers::resolver_function_t *_resolver) const
16096 {
16097   (void)_o;
16098   (void)_resolver;
16099   {
16100     auto _e = time_major();
16101     _o->time_major = _e;
16102   }
16103   {
16104     auto _e = fused_activation_function();
16105     _o->fused_activation_function = _e;
16106   }
16107   {
16108     auto _e = asymmetric_quantize_inputs();
16109     _o->asymmetric_quantize_inputs = _e;
16110   }
16111 }
16112
16113 inline flatbuffers::Offset<SequenceRNNOptions>
16114 SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o,
16115                          const flatbuffers::rehasher_function_t *_rehasher)
16116 {
16117   return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
16118 }
16119
16120 inline flatbuffers::Offset<SequenceRNNOptions>
16121 CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o,
16122                          const flatbuffers::rehasher_function_t *_rehasher)
16123 {
16124   (void)_rehasher;
16125   (void)_o;
16126   struct _VectorArgs
16127   {
16128     flatbuffers::FlatBufferBuilder *__fbb;
16129     const SequenceRNNOptionsT *__o;
16130     const flatbuffers::rehasher_function_t *__rehasher;
16131   } _va = {&_fbb, _o, _rehasher};
16132   (void)_va;
16133   auto _time_major = _o->time_major;
16134   auto _fused_activation_function = _o->fused_activation_function;
16135   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16136   return circle::CreateSequenceRNNOptions(_fbb, _time_major, _fused_activation_function,
16137                                           _asymmetric_quantize_inputs);
16138 }
16139
16140 inline BidirectionalSequenceRNNOptionsT *
16141 BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16142 {
16143   auto _o =
16144     std::unique_ptr<BidirectionalSequenceRNNOptionsT>(new BidirectionalSequenceRNNOptionsT());
16145   UnPackTo(_o.get(), _resolver);
16146   return _o.release();
16147 }
16148
16149 inline void
16150 BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o,
16151                                           const flatbuffers::resolver_function_t *_resolver) const
16152 {
16153   (void)_o;
16154   (void)_resolver;
16155   {
16156     auto _e = time_major();
16157     _o->time_major = _e;
16158   }
16159   {
16160     auto _e = fused_activation_function();
16161     _o->fused_activation_function = _e;
16162   }
16163   {
16164     auto _e = merge_outputs();
16165     _o->merge_outputs = _e;
16166   }
16167   {
16168     auto _e = asymmetric_quantize_inputs();
16169     _o->asymmetric_quantize_inputs = _e;
16170   }
16171 }
16172
16173 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions>
16174 BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
16175                                       const BidirectionalSequenceRNNOptionsT *_o,
16176                                       const flatbuffers::rehasher_function_t *_rehasher)
16177 {
16178   return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
16179 }
16180
16181 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions>
16182 CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb,
16183                                       const BidirectionalSequenceRNNOptionsT *_o,
16184                                       const flatbuffers::rehasher_function_t *_rehasher)
16185 {
16186   (void)_rehasher;
16187   (void)_o;
16188   struct _VectorArgs
16189   {
16190     flatbuffers::FlatBufferBuilder *__fbb;
16191     const BidirectionalSequenceRNNOptionsT *__o;
16192     const flatbuffers::rehasher_function_t *__rehasher;
16193   } _va = {&_fbb, _o, _rehasher};
16194   (void)_va;
16195   auto _time_major = _o->time_major;
16196   auto _fused_activation_function = _o->fused_activation_function;
16197   auto _merge_outputs = _o->merge_outputs;
16198   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16199   return circle::CreateBidirectionalSequenceRNNOptions(
16200     _fbb, _time_major, _fused_activation_function, _merge_outputs, _asymmetric_quantize_inputs);
16201 }
16202
16203 inline FullyConnectedOptionsT *
16204 FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16205 {
16206   auto _o = std::unique_ptr<FullyConnectedOptionsT>(new FullyConnectedOptionsT());
16207   UnPackTo(_o.get(), _resolver);
16208   return _o.release();
16209 }
16210
16211 inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o,
16212                                             const flatbuffers::resolver_function_t *_resolver) const
16213 {
16214   (void)_o;
16215   (void)_resolver;
16216   {
16217     auto _e = fused_activation_function();
16218     _o->fused_activation_function = _e;
16219   }
16220   {
16221     auto _e = weights_format();
16222     _o->weights_format = _e;
16223   }
16224   {
16225     auto _e = keep_num_dims();
16226     _o->keep_num_dims = _e;
16227   }
16228   {
16229     auto _e = asymmetric_quantize_inputs();
16230     _o->asymmetric_quantize_inputs = _e;
16231   }
16232 }
16233
16234 inline flatbuffers::Offset<FullyConnectedOptions>
16235 FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o,
16236                             const flatbuffers::rehasher_function_t *_rehasher)
16237 {
16238   return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
16239 }
16240
16241 inline flatbuffers::Offset<FullyConnectedOptions>
16242 CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o,
16243                             const flatbuffers::rehasher_function_t *_rehasher)
16244 {
16245   (void)_rehasher;
16246   (void)_o;
16247   struct _VectorArgs
16248   {
16249     flatbuffers::FlatBufferBuilder *__fbb;
16250     const FullyConnectedOptionsT *__o;
16251     const flatbuffers::rehasher_function_t *__rehasher;
16252   } _va = {&_fbb, _o, _rehasher};
16253   (void)_va;
16254   auto _fused_activation_function = _o->fused_activation_function;
16255   auto _weights_format = _o->weights_format;
16256   auto _keep_num_dims = _o->keep_num_dims;
16257   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16258   return circle::CreateFullyConnectedOptions(_fbb, _fused_activation_function, _weights_format,
16259                                              _keep_num_dims, _asymmetric_quantize_inputs);
16260 }
16261
16262 inline SoftmaxOptionsT *
16263 SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16264 {
16265   auto _o = std::unique_ptr<SoftmaxOptionsT>(new SoftmaxOptionsT());
16266   UnPackTo(_o.get(), _resolver);
16267   return _o.release();
16268 }
16269
16270 inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o,
16271                                      const flatbuffers::resolver_function_t *_resolver) const
16272 {
16273   (void)_o;
16274   (void)_resolver;
16275   {
16276     auto _e = beta();
16277     _o->beta = _e;
16278   }
16279 }
16280
16281 inline flatbuffers::Offset<SoftmaxOptions>
16282 SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o,
16283                      const flatbuffers::rehasher_function_t *_rehasher)
16284 {
16285   return CreateSoftmaxOptions(_fbb, _o, _rehasher);
16286 }
16287
16288 inline flatbuffers::Offset<SoftmaxOptions>
16289 CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o,
16290                      const flatbuffers::rehasher_function_t *_rehasher)
16291 {
16292   (void)_rehasher;
16293   (void)_o;
16294   struct _VectorArgs
16295   {
16296     flatbuffers::FlatBufferBuilder *__fbb;
16297     const SoftmaxOptionsT *__o;
16298     const flatbuffers::rehasher_function_t *__rehasher;
16299   } _va = {&_fbb, _o, _rehasher};
16300   (void)_va;
16301   auto _beta = _o->beta;
16302   return circle::CreateSoftmaxOptions(_fbb, _beta);
16303 }
16304
16305 inline ConcatenationOptionsT *
16306 ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16307 {
16308   auto _o = std::unique_ptr<ConcatenationOptionsT>(new ConcatenationOptionsT());
16309   UnPackTo(_o.get(), _resolver);
16310   return _o.release();
16311 }
16312
16313 inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o,
16314                                            const flatbuffers::resolver_function_t *_resolver) const
16315 {
16316   (void)_o;
16317   (void)_resolver;
16318   {
16319     auto _e = axis();
16320     _o->axis = _e;
16321   }
16322   {
16323     auto _e = fused_activation_function();
16324     _o->fused_activation_function = _e;
16325   }
16326 }
16327
16328 inline flatbuffers::Offset<ConcatenationOptions>
16329 ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o,
16330                            const flatbuffers::rehasher_function_t *_rehasher)
16331 {
16332   return CreateConcatenationOptions(_fbb, _o, _rehasher);
16333 }
16334
16335 inline flatbuffers::Offset<ConcatenationOptions>
16336 CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o,
16337                            const flatbuffers::rehasher_function_t *_rehasher)
16338 {
16339   (void)_rehasher;
16340   (void)_o;
16341   struct _VectorArgs
16342   {
16343     flatbuffers::FlatBufferBuilder *__fbb;
16344     const ConcatenationOptionsT *__o;
16345     const flatbuffers::rehasher_function_t *__rehasher;
16346   } _va = {&_fbb, _o, _rehasher};
16347   (void)_va;
16348   auto _axis = _o->axis;
16349   auto _fused_activation_function = _o->fused_activation_function;
16350   return circle::CreateConcatenationOptions(_fbb, _axis, _fused_activation_function);
16351 }
16352
16353 inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16354 {
16355   auto _o = std::unique_ptr<AddOptionsT>(new AddOptionsT());
16356   UnPackTo(_o.get(), _resolver);
16357   return _o.release();
16358 }
16359
16360 inline void AddOptions::UnPackTo(AddOptionsT *_o,
16361                                  const flatbuffers::resolver_function_t *_resolver) const
16362 {
16363   (void)_o;
16364   (void)_resolver;
16365   {
16366     auto _e = fused_activation_function();
16367     _o->fused_activation_function = _e;
16368   }
16369   {
16370     auto _e = pot_scale_int16();
16371     _o->pot_scale_int16 = _e;
16372   }
16373 }
16374
16375 inline flatbuffers::Offset<AddOptions>
16376 AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o,
16377                  const flatbuffers::rehasher_function_t *_rehasher)
16378 {
16379   return CreateAddOptions(_fbb, _o, _rehasher);
16380 }
16381
16382 inline flatbuffers::Offset<AddOptions>
16383 CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o,
16384                  const flatbuffers::rehasher_function_t *_rehasher)
16385 {
16386   (void)_rehasher;
16387   (void)_o;
16388   struct _VectorArgs
16389   {
16390     flatbuffers::FlatBufferBuilder *__fbb;
16391     const AddOptionsT *__o;
16392     const flatbuffers::rehasher_function_t *__rehasher;
16393   } _va = {&_fbb, _o, _rehasher};
16394   (void)_va;
16395   auto _fused_activation_function = _o->fused_activation_function;
16396   auto _pot_scale_int16 = _o->pot_scale_int16;
16397   return circle::CreateAddOptions(_fbb, _fused_activation_function, _pot_scale_int16);
16398 }
16399
16400 inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16401 {
16402   auto _o = std::unique_ptr<MulOptionsT>(new MulOptionsT());
16403   UnPackTo(_o.get(), _resolver);
16404   return _o.release();
16405 }
16406
16407 inline void MulOptions::UnPackTo(MulOptionsT *_o,
16408                                  const flatbuffers::resolver_function_t *_resolver) const
16409 {
16410   (void)_o;
16411   (void)_resolver;
16412   {
16413     auto _e = fused_activation_function();
16414     _o->fused_activation_function = _e;
16415   }
16416 }
16417
16418 inline flatbuffers::Offset<MulOptions>
16419 MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o,
16420                  const flatbuffers::rehasher_function_t *_rehasher)
16421 {
16422   return CreateMulOptions(_fbb, _o, _rehasher);
16423 }
16424
16425 inline flatbuffers::Offset<MulOptions>
16426 CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o,
16427                  const flatbuffers::rehasher_function_t *_rehasher)
16428 {
16429   (void)_rehasher;
16430   (void)_o;
16431   struct _VectorArgs
16432   {
16433     flatbuffers::FlatBufferBuilder *__fbb;
16434     const MulOptionsT *__o;
16435     const flatbuffers::rehasher_function_t *__rehasher;
16436   } _va = {&_fbb, _o, _rehasher};
16437   (void)_va;
16438   auto _fused_activation_function = _o->fused_activation_function;
16439   return circle::CreateMulOptions(_fbb, _fused_activation_function);
16440 }
16441
16442 inline L2NormOptionsT *
16443 L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16444 {
16445   auto _o = std::unique_ptr<L2NormOptionsT>(new L2NormOptionsT());
16446   UnPackTo(_o.get(), _resolver);
16447   return _o.release();
16448 }
16449
16450 inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o,
16451                                     const flatbuffers::resolver_function_t *_resolver) const
16452 {
16453   (void)_o;
16454   (void)_resolver;
16455   {
16456     auto _e = fused_activation_function();
16457     _o->fused_activation_function = _e;
16458   }
16459 }
16460
16461 inline flatbuffers::Offset<L2NormOptions>
16462 L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o,
16463                     const flatbuffers::rehasher_function_t *_rehasher)
16464 {
16465   return CreateL2NormOptions(_fbb, _o, _rehasher);
16466 }
16467
16468 inline flatbuffers::Offset<L2NormOptions>
16469 CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o,
16470                     const flatbuffers::rehasher_function_t *_rehasher)
16471 {
16472   (void)_rehasher;
16473   (void)_o;
16474   struct _VectorArgs
16475   {
16476     flatbuffers::FlatBufferBuilder *__fbb;
16477     const L2NormOptionsT *__o;
16478     const flatbuffers::rehasher_function_t *__rehasher;
16479   } _va = {&_fbb, _o, _rehasher};
16480   (void)_va;
16481   auto _fused_activation_function = _o->fused_activation_function;
16482   return circle::CreateL2NormOptions(_fbb, _fused_activation_function);
16483 }
16484
16485 inline LocalResponseNormalizationOptionsT *
16486 LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16487 {
16488   auto _o =
16489     std::unique_ptr<LocalResponseNormalizationOptionsT>(new LocalResponseNormalizationOptionsT());
16490   UnPackTo(_o.get(), _resolver);
16491   return _o.release();
16492 }
16493
16494 inline void
16495 LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o,
16496                                             const flatbuffers::resolver_function_t *_resolver) const
16497 {
16498   (void)_o;
16499   (void)_resolver;
16500   {
16501     auto _e = radius();
16502     _o->radius = _e;
16503   }
16504   {
16505     auto _e = bias();
16506     _o->bias = _e;
16507   }
16508   {
16509     auto _e = alpha();
16510     _o->alpha = _e;
16511   }
16512   {
16513     auto _e = beta();
16514     _o->beta = _e;
16515   }
16516 }
16517
16518 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
16519 LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
16520                                         const LocalResponseNormalizationOptionsT *_o,
16521                                         const flatbuffers::rehasher_function_t *_rehasher)
16522 {
16523   return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
16524 }
16525
16526 inline flatbuffers::Offset<LocalResponseNormalizationOptions>
16527 CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb,
16528                                         const LocalResponseNormalizationOptionsT *_o,
16529                                         const flatbuffers::rehasher_function_t *_rehasher)
16530 {
16531   (void)_rehasher;
16532   (void)_o;
16533   struct _VectorArgs
16534   {
16535     flatbuffers::FlatBufferBuilder *__fbb;
16536     const LocalResponseNormalizationOptionsT *__o;
16537     const flatbuffers::rehasher_function_t *__rehasher;
16538   } _va = {&_fbb, _o, _rehasher};
16539   (void)_va;
16540   auto _radius = _o->radius;
16541   auto _bias = _o->bias;
16542   auto _alpha = _o->alpha;
16543   auto _beta = _o->beta;
16544   return circle::CreateLocalResponseNormalizationOptions(_fbb, _radius, _bias, _alpha, _beta);
16545 }
16546
16547 inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16548 {
16549   auto _o = std::unique_ptr<LSTMOptionsT>(new LSTMOptionsT());
16550   UnPackTo(_o.get(), _resolver);
16551   return _o.release();
16552 }
16553
16554 inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o,
16555                                   const flatbuffers::resolver_function_t *_resolver) const
16556 {
16557   (void)_o;
16558   (void)_resolver;
16559   {
16560     auto _e = fused_activation_function();
16561     _o->fused_activation_function = _e;
16562   }
16563   {
16564     auto _e = cell_clip();
16565     _o->cell_clip = _e;
16566   }
16567   {
16568     auto _e = proj_clip();
16569     _o->proj_clip = _e;
16570   }
16571   {
16572     auto _e = kernel_type();
16573     _o->kernel_type = _e;
16574   }
16575   {
16576     auto _e = asymmetric_quantize_inputs();
16577     _o->asymmetric_quantize_inputs = _e;
16578   }
16579 }
16580
16581 inline flatbuffers::Offset<LSTMOptions>
16582 LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o,
16583                   const flatbuffers::rehasher_function_t *_rehasher)
16584 {
16585   return CreateLSTMOptions(_fbb, _o, _rehasher);
16586 }
16587
16588 inline flatbuffers::Offset<LSTMOptions>
16589 CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o,
16590                   const flatbuffers::rehasher_function_t *_rehasher)
16591 {
16592   (void)_rehasher;
16593   (void)_o;
16594   struct _VectorArgs
16595   {
16596     flatbuffers::FlatBufferBuilder *__fbb;
16597     const LSTMOptionsT *__o;
16598     const flatbuffers::rehasher_function_t *__rehasher;
16599   } _va = {&_fbb, _o, _rehasher};
16600   (void)_va;
16601   auto _fused_activation_function = _o->fused_activation_function;
16602   auto _cell_clip = _o->cell_clip;
16603   auto _proj_clip = _o->proj_clip;
16604   auto _kernel_type = _o->kernel_type;
16605   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16606   return circle::CreateLSTMOptions(_fbb, _fused_activation_function, _cell_clip, _proj_clip,
16607                                    _kernel_type, _asymmetric_quantize_inputs);
16608 }
16609
16610 inline UnidirectionalSequenceLSTMOptionsT *
16611 UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16612 {
16613   auto _o =
16614     std::unique_ptr<UnidirectionalSequenceLSTMOptionsT>(new UnidirectionalSequenceLSTMOptionsT());
16615   UnPackTo(_o.get(), _resolver);
16616   return _o.release();
16617 }
16618
16619 inline void
16620 UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o,
16621                                             const flatbuffers::resolver_function_t *_resolver) const
16622 {
16623   (void)_o;
16624   (void)_resolver;
16625   {
16626     auto _e = fused_activation_function();
16627     _o->fused_activation_function = _e;
16628   }
16629   {
16630     auto _e = cell_clip();
16631     _o->cell_clip = _e;
16632   }
16633   {
16634     auto _e = proj_clip();
16635     _o->proj_clip = _e;
16636   }
16637   {
16638     auto _e = time_major();
16639     _o->time_major = _e;
16640   }
16641   {
16642     auto _e = asymmetric_quantize_inputs();
16643     _o->asymmetric_quantize_inputs = _e;
16644   }
16645 }
16646
16647 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
16648 UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
16649                                         const UnidirectionalSequenceLSTMOptionsT *_o,
16650                                         const flatbuffers::rehasher_function_t *_rehasher)
16651 {
16652   return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
16653 }
16654
16655 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>
16656 CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb,
16657                                         const UnidirectionalSequenceLSTMOptionsT *_o,
16658                                         const flatbuffers::rehasher_function_t *_rehasher)
16659 {
16660   (void)_rehasher;
16661   (void)_o;
16662   struct _VectorArgs
16663   {
16664     flatbuffers::FlatBufferBuilder *__fbb;
16665     const UnidirectionalSequenceLSTMOptionsT *__o;
16666     const flatbuffers::rehasher_function_t *__rehasher;
16667   } _va = {&_fbb, _o, _rehasher};
16668   (void)_va;
16669   auto _fused_activation_function = _o->fused_activation_function;
16670   auto _cell_clip = _o->cell_clip;
16671   auto _proj_clip = _o->proj_clip;
16672   auto _time_major = _o->time_major;
16673   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16674   return circle::CreateUnidirectionalSequenceLSTMOptions(_fbb, _fused_activation_function,
16675                                                          _cell_clip, _proj_clip, _time_major,
16676                                                          _asymmetric_quantize_inputs);
16677 }
16678
16679 inline BidirectionalSequenceLSTMOptionsT *
16680 BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16681 {
16682   auto _o =
16683     std::unique_ptr<BidirectionalSequenceLSTMOptionsT>(new BidirectionalSequenceLSTMOptionsT());
16684   UnPackTo(_o.get(), _resolver);
16685   return _o.release();
16686 }
16687
16688 inline void
16689 BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o,
16690                                            const flatbuffers::resolver_function_t *_resolver) const
16691 {
16692   (void)_o;
16693   (void)_resolver;
16694   {
16695     auto _e = fused_activation_function();
16696     _o->fused_activation_function = _e;
16697   }
16698   {
16699     auto _e = cell_clip();
16700     _o->cell_clip = _e;
16701   }
16702   {
16703     auto _e = proj_clip();
16704     _o->proj_clip = _e;
16705   }
16706   {
16707     auto _e = merge_outputs();
16708     _o->merge_outputs = _e;
16709   }
16710   {
16711     auto _e = time_major();
16712     _o->time_major = _e;
16713   }
16714   {
16715     auto _e = asymmetric_quantize_inputs();
16716     _o->asymmetric_quantize_inputs = _e;
16717   }
16718 }
16719
16720 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions>
16721 BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
16722                                        const BidirectionalSequenceLSTMOptionsT *_o,
16723                                        const flatbuffers::rehasher_function_t *_rehasher)
16724 {
16725   return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
16726 }
16727
16728 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions>
16729 CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb,
16730                                        const BidirectionalSequenceLSTMOptionsT *_o,
16731                                        const flatbuffers::rehasher_function_t *_rehasher)
16732 {
16733   (void)_rehasher;
16734   (void)_o;
16735   struct _VectorArgs
16736   {
16737     flatbuffers::FlatBufferBuilder *__fbb;
16738     const BidirectionalSequenceLSTMOptionsT *__o;
16739     const flatbuffers::rehasher_function_t *__rehasher;
16740   } _va = {&_fbb, _o, _rehasher};
16741   (void)_va;
16742   auto _fused_activation_function = _o->fused_activation_function;
16743   auto _cell_clip = _o->cell_clip;
16744   auto _proj_clip = _o->proj_clip;
16745   auto _merge_outputs = _o->merge_outputs;
16746   auto _time_major = _o->time_major;
16747   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16748   return circle::CreateBidirectionalSequenceLSTMOptions(_fbb, _fused_activation_function,
16749                                                         _cell_clip, _proj_clip, _merge_outputs,
16750                                                         _time_major, _asymmetric_quantize_inputs);
16751 }
16752
16753 inline ResizeBilinearOptionsT *
16754 ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16755 {
16756   auto _o = std::unique_ptr<ResizeBilinearOptionsT>(new ResizeBilinearOptionsT());
16757   UnPackTo(_o.get(), _resolver);
16758   return _o.release();
16759 }
16760
16761 inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o,
16762                                             const flatbuffers::resolver_function_t *_resolver) const
16763 {
16764   (void)_o;
16765   (void)_resolver;
16766   {
16767     auto _e = align_corners();
16768     _o->align_corners = _e;
16769   }
16770   {
16771     auto _e = half_pixel_centers();
16772     _o->half_pixel_centers = _e;
16773   }
16774 }
16775
16776 inline flatbuffers::Offset<ResizeBilinearOptions>
16777 ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o,
16778                             const flatbuffers::rehasher_function_t *_rehasher)
16779 {
16780   return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
16781 }
16782
16783 inline flatbuffers::Offset<ResizeBilinearOptions>
16784 CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o,
16785                             const flatbuffers::rehasher_function_t *_rehasher)
16786 {
16787   (void)_rehasher;
16788   (void)_o;
16789   struct _VectorArgs
16790   {
16791     flatbuffers::FlatBufferBuilder *__fbb;
16792     const ResizeBilinearOptionsT *__o;
16793     const flatbuffers::rehasher_function_t *__rehasher;
16794   } _va = {&_fbb, _o, _rehasher};
16795   (void)_va;
16796   auto _align_corners = _o->align_corners;
16797   auto _half_pixel_centers = _o->half_pixel_centers;
16798   return circle::CreateResizeBilinearOptions(_fbb, _align_corners, _half_pixel_centers);
16799 }
16800
16801 inline ResizeNearestNeighborOptionsT *
16802 ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16803 {
16804   auto _o = std::unique_ptr<ResizeNearestNeighborOptionsT>(new ResizeNearestNeighborOptionsT());
16805   UnPackTo(_o.get(), _resolver);
16806   return _o.release();
16807 }
16808
16809 inline void
16810 ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o,
16811                                        const flatbuffers::resolver_function_t *_resolver) const
16812 {
16813   (void)_o;
16814   (void)_resolver;
16815   {
16816     auto _e = align_corners();
16817     _o->align_corners = _e;
16818   }
16819   {
16820     auto _e = half_pixel_centers();
16821     _o->half_pixel_centers = _e;
16822   }
16823 }
16824
16825 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
16826 ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
16827                                    const ResizeNearestNeighborOptionsT *_o,
16828                                    const flatbuffers::rehasher_function_t *_rehasher)
16829 {
16830   return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
16831 }
16832
16833 inline flatbuffers::Offset<ResizeNearestNeighborOptions>
16834 CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb,
16835                                    const ResizeNearestNeighborOptionsT *_o,
16836                                    const flatbuffers::rehasher_function_t *_rehasher)
16837 {
16838   (void)_rehasher;
16839   (void)_o;
16840   struct _VectorArgs
16841   {
16842     flatbuffers::FlatBufferBuilder *__fbb;
16843     const ResizeNearestNeighborOptionsT *__o;
16844     const flatbuffers::rehasher_function_t *__rehasher;
16845   } _va = {&_fbb, _o, _rehasher};
16846   (void)_va;
16847   auto _align_corners = _o->align_corners;
16848   auto _half_pixel_centers = _o->half_pixel_centers;
16849   return circle::CreateResizeNearestNeighborOptions(_fbb, _align_corners, _half_pixel_centers);
16850 }
16851
16852 inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16853 {
16854   auto _o = std::unique_ptr<CallOptionsT>(new CallOptionsT());
16855   UnPackTo(_o.get(), _resolver);
16856   return _o.release();
16857 }
16858
16859 inline void CallOptions::UnPackTo(CallOptionsT *_o,
16860                                   const flatbuffers::resolver_function_t *_resolver) const
16861 {
16862   (void)_o;
16863   (void)_resolver;
16864   {
16865     auto _e = subgraph();
16866     _o->subgraph = _e;
16867   }
16868 }
16869
16870 inline flatbuffers::Offset<CallOptions>
16871 CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o,
16872                   const flatbuffers::rehasher_function_t *_rehasher)
16873 {
16874   return CreateCallOptions(_fbb, _o, _rehasher);
16875 }
16876
16877 inline flatbuffers::Offset<CallOptions>
16878 CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o,
16879                   const flatbuffers::rehasher_function_t *_rehasher)
16880 {
16881   (void)_rehasher;
16882   (void)_o;
16883   struct _VectorArgs
16884   {
16885     flatbuffers::FlatBufferBuilder *__fbb;
16886     const CallOptionsT *__o;
16887     const flatbuffers::rehasher_function_t *__rehasher;
16888   } _va = {&_fbb, _o, _rehasher};
16889   (void)_va;
16890   auto _subgraph = _o->subgraph;
16891   return circle::CreateCallOptions(_fbb, _subgraph);
16892 }
16893
16894 inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16895 {
16896   auto _o = std::unique_ptr<PadOptionsT>(new PadOptionsT());
16897   UnPackTo(_o.get(), _resolver);
16898   return _o.release();
16899 }
16900
16901 inline void PadOptions::UnPackTo(PadOptionsT *_o,
16902                                  const flatbuffers::resolver_function_t *_resolver) const
16903 {
16904   (void)_o;
16905   (void)_resolver;
16906 }
16907
16908 inline flatbuffers::Offset<PadOptions>
16909 PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o,
16910                  const flatbuffers::rehasher_function_t *_rehasher)
16911 {
16912   return CreatePadOptions(_fbb, _o, _rehasher);
16913 }
16914
16915 inline flatbuffers::Offset<PadOptions>
16916 CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o,
16917                  const flatbuffers::rehasher_function_t *_rehasher)
16918 {
16919   (void)_rehasher;
16920   (void)_o;
16921   struct _VectorArgs
16922   {
16923     flatbuffers::FlatBufferBuilder *__fbb;
16924     const PadOptionsT *__o;
16925     const flatbuffers::rehasher_function_t *__rehasher;
16926   } _va = {&_fbb, _o, _rehasher};
16927   (void)_va;
16928   return circle::CreatePadOptions(_fbb);
16929 }
16930
16931 inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16932 {
16933   auto _o = std::unique_ptr<PadV2OptionsT>(new PadV2OptionsT());
16934   UnPackTo(_o.get(), _resolver);
16935   return _o.release();
16936 }
16937
16938 inline void PadV2Options::UnPackTo(PadV2OptionsT *_o,
16939                                    const flatbuffers::resolver_function_t *_resolver) const
16940 {
16941   (void)_o;
16942   (void)_resolver;
16943 }
16944
16945 inline flatbuffers::Offset<PadV2Options>
16946 PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o,
16947                    const flatbuffers::rehasher_function_t *_rehasher)
16948 {
16949   return CreatePadV2Options(_fbb, _o, _rehasher);
16950 }
16951
16952 inline flatbuffers::Offset<PadV2Options>
16953 CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o,
16954                    const flatbuffers::rehasher_function_t *_rehasher)
16955 {
16956   (void)_rehasher;
16957   (void)_o;
16958   struct _VectorArgs
16959   {
16960     flatbuffers::FlatBufferBuilder *__fbb;
16961     const PadV2OptionsT *__o;
16962     const flatbuffers::rehasher_function_t *__rehasher;
16963   } _va = {&_fbb, _o, _rehasher};
16964   (void)_va;
16965   return circle::CreatePadV2Options(_fbb);
16966 }
16967
16968 inline ReshapeOptionsT *
16969 ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
16970 {
16971   auto _o = std::unique_ptr<ReshapeOptionsT>(new ReshapeOptionsT());
16972   UnPackTo(_o.get(), _resolver);
16973   return _o.release();
16974 }
16975
16976 inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o,
16977                                      const flatbuffers::resolver_function_t *_resolver) const
16978 {
16979   (void)_o;
16980   (void)_resolver;
16981   {
16982     auto _e = new_shape();
16983     if (_e)
16984     {
16985       _o->new_shape.resize(_e->size());
16986       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
16987       {
16988         _o->new_shape[_i] = _e->Get(_i);
16989       }
16990     }
16991   }
16992 }
16993
16994 inline flatbuffers::Offset<ReshapeOptions>
16995 ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o,
16996                      const flatbuffers::rehasher_function_t *_rehasher)
16997 {
16998   return CreateReshapeOptions(_fbb, _o, _rehasher);
16999 }
17000
17001 inline flatbuffers::Offset<ReshapeOptions>
17002 CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o,
17003                      const flatbuffers::rehasher_function_t *_rehasher)
17004 {
17005   (void)_rehasher;
17006   (void)_o;
17007   struct _VectorArgs
17008   {
17009     flatbuffers::FlatBufferBuilder *__fbb;
17010     const ReshapeOptionsT *__o;
17011     const flatbuffers::rehasher_function_t *__rehasher;
17012   } _va = {&_fbb, _o, _rehasher};
17013   (void)_va;
17014   auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0;
17015   return circle::CreateReshapeOptions(_fbb, _new_shape);
17016 }
17017
17018 inline SpaceToBatchNDOptionsT *
17019 SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17020 {
17021   auto _o = std::unique_ptr<SpaceToBatchNDOptionsT>(new SpaceToBatchNDOptionsT());
17022   UnPackTo(_o.get(), _resolver);
17023   return _o.release();
17024 }
17025
17026 inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o,
17027                                             const flatbuffers::resolver_function_t *_resolver) const
17028 {
17029   (void)_o;
17030   (void)_resolver;
17031 }
17032
17033 inline flatbuffers::Offset<SpaceToBatchNDOptions>
17034 SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o,
17035                             const flatbuffers::rehasher_function_t *_rehasher)
17036 {
17037   return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
17038 }
17039
17040 inline flatbuffers::Offset<SpaceToBatchNDOptions>
17041 CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o,
17042                             const flatbuffers::rehasher_function_t *_rehasher)
17043 {
17044   (void)_rehasher;
17045   (void)_o;
17046   struct _VectorArgs
17047   {
17048     flatbuffers::FlatBufferBuilder *__fbb;
17049     const SpaceToBatchNDOptionsT *__o;
17050     const flatbuffers::rehasher_function_t *__rehasher;
17051   } _va = {&_fbb, _o, _rehasher};
17052   (void)_va;
17053   return circle::CreateSpaceToBatchNDOptions(_fbb);
17054 }
17055
17056 inline BatchToSpaceNDOptionsT *
17057 BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17058 {
17059   auto _o = std::unique_ptr<BatchToSpaceNDOptionsT>(new BatchToSpaceNDOptionsT());
17060   UnPackTo(_o.get(), _resolver);
17061   return _o.release();
17062 }
17063
17064 inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o,
17065                                             const flatbuffers::resolver_function_t *_resolver) const
17066 {
17067   (void)_o;
17068   (void)_resolver;
17069 }
17070
17071 inline flatbuffers::Offset<BatchToSpaceNDOptions>
17072 BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o,
17073                             const flatbuffers::rehasher_function_t *_rehasher)
17074 {
17075   return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
17076 }
17077
17078 inline flatbuffers::Offset<BatchToSpaceNDOptions>
17079 CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o,
17080                             const flatbuffers::rehasher_function_t *_rehasher)
17081 {
17082   (void)_rehasher;
17083   (void)_o;
17084   struct _VectorArgs
17085   {
17086     flatbuffers::FlatBufferBuilder *__fbb;
17087     const BatchToSpaceNDOptionsT *__o;
17088     const flatbuffers::rehasher_function_t *__rehasher;
17089   } _va = {&_fbb, _o, _rehasher};
17090   (void)_va;
17091   return circle::CreateBatchToSpaceNDOptions(_fbb);
17092 }
17093
17094 inline SkipGramOptionsT *
17095 SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17096 {
17097   auto _o = std::unique_ptr<SkipGramOptionsT>(new SkipGramOptionsT());
17098   UnPackTo(_o.get(), _resolver);
17099   return _o.release();
17100 }
17101
17102 inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o,
17103                                       const flatbuffers::resolver_function_t *_resolver) const
17104 {
17105   (void)_o;
17106   (void)_resolver;
17107   {
17108     auto _e = ngram_size();
17109     _o->ngram_size = _e;
17110   }
17111   {
17112     auto _e = max_skip_size();
17113     _o->max_skip_size = _e;
17114   }
17115   {
17116     auto _e = include_all_ngrams();
17117     _o->include_all_ngrams = _e;
17118   }
17119 }
17120
17121 inline flatbuffers::Offset<SkipGramOptions>
17122 SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o,
17123                       const flatbuffers::rehasher_function_t *_rehasher)
17124 {
17125   return CreateSkipGramOptions(_fbb, _o, _rehasher);
17126 }
17127
17128 inline flatbuffers::Offset<SkipGramOptions>
17129 CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o,
17130                       const flatbuffers::rehasher_function_t *_rehasher)
17131 {
17132   (void)_rehasher;
17133   (void)_o;
17134   struct _VectorArgs
17135   {
17136     flatbuffers::FlatBufferBuilder *__fbb;
17137     const SkipGramOptionsT *__o;
17138     const flatbuffers::rehasher_function_t *__rehasher;
17139   } _va = {&_fbb, _o, _rehasher};
17140   (void)_va;
17141   auto _ngram_size = _o->ngram_size;
17142   auto _max_skip_size = _o->max_skip_size;
17143   auto _include_all_ngrams = _o->include_all_ngrams;
17144   return circle::CreateSkipGramOptions(_fbb, _ngram_size, _max_skip_size, _include_all_ngrams);
17145 }
17146
17147 inline SpaceToDepthOptionsT *
17148 SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17149 {
17150   auto _o = std::unique_ptr<SpaceToDepthOptionsT>(new SpaceToDepthOptionsT());
17151   UnPackTo(_o.get(), _resolver);
17152   return _o.release();
17153 }
17154
17155 inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o,
17156                                           const flatbuffers::resolver_function_t *_resolver) const
17157 {
17158   (void)_o;
17159   (void)_resolver;
17160   {
17161     auto _e = block_size();
17162     _o->block_size = _e;
17163   }
17164 }
17165
17166 inline flatbuffers::Offset<SpaceToDepthOptions>
17167 SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o,
17168                           const flatbuffers::rehasher_function_t *_rehasher)
17169 {
17170   return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
17171 }
17172
17173 inline flatbuffers::Offset<SpaceToDepthOptions>
17174 CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o,
17175                           const flatbuffers::rehasher_function_t *_rehasher)
17176 {
17177   (void)_rehasher;
17178   (void)_o;
17179   struct _VectorArgs
17180   {
17181     flatbuffers::FlatBufferBuilder *__fbb;
17182     const SpaceToDepthOptionsT *__o;
17183     const flatbuffers::rehasher_function_t *__rehasher;
17184   } _va = {&_fbb, _o, _rehasher};
17185   (void)_va;
17186   auto _block_size = _o->block_size;
17187   return circle::CreateSpaceToDepthOptions(_fbb, _block_size);
17188 }
17189
17190 inline DepthToSpaceOptionsT *
17191 DepthToSpaceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17192 {
17193   auto _o = std::unique_ptr<DepthToSpaceOptionsT>(new DepthToSpaceOptionsT());
17194   UnPackTo(_o.get(), _resolver);
17195   return _o.release();
17196 }
17197
17198 inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o,
17199                                           const flatbuffers::resolver_function_t *_resolver) const
17200 {
17201   (void)_o;
17202   (void)_resolver;
17203   {
17204     auto _e = block_size();
17205     _o->block_size = _e;
17206   }
17207 }
17208
17209 inline flatbuffers::Offset<DepthToSpaceOptions>
17210 DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o,
17211                           const flatbuffers::rehasher_function_t *_rehasher)
17212 {
17213   return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
17214 }
17215
17216 inline flatbuffers::Offset<DepthToSpaceOptions>
17217 CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o,
17218                           const flatbuffers::rehasher_function_t *_rehasher)
17219 {
17220   (void)_rehasher;
17221   (void)_o;
17222   struct _VectorArgs
17223   {
17224     flatbuffers::FlatBufferBuilder *__fbb;
17225     const DepthToSpaceOptionsT *__o;
17226     const flatbuffers::rehasher_function_t *__rehasher;
17227   } _va = {&_fbb, _o, _rehasher};
17228   (void)_va;
17229   auto _block_size = _o->block_size;
17230   return circle::CreateDepthToSpaceOptions(_fbb, _block_size);
17231 }
17232
17233 inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17234 {
17235   auto _o = std::unique_ptr<SubOptionsT>(new SubOptionsT());
17236   UnPackTo(_o.get(), _resolver);
17237   return _o.release();
17238 }
17239
17240 inline void SubOptions::UnPackTo(SubOptionsT *_o,
17241                                  const flatbuffers::resolver_function_t *_resolver) const
17242 {
17243   (void)_o;
17244   (void)_resolver;
17245   {
17246     auto _e = fused_activation_function();
17247     _o->fused_activation_function = _e;
17248   }
17249   {
17250     auto _e = pot_scale_int16();
17251     _o->pot_scale_int16 = _e;
17252   }
17253 }
17254
17255 inline flatbuffers::Offset<SubOptions>
17256 SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o,
17257                  const flatbuffers::rehasher_function_t *_rehasher)
17258 {
17259   return CreateSubOptions(_fbb, _o, _rehasher);
17260 }
17261
17262 inline flatbuffers::Offset<SubOptions>
17263 CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o,
17264                  const flatbuffers::rehasher_function_t *_rehasher)
17265 {
17266   (void)_rehasher;
17267   (void)_o;
17268   struct _VectorArgs
17269   {
17270     flatbuffers::FlatBufferBuilder *__fbb;
17271     const SubOptionsT *__o;
17272     const flatbuffers::rehasher_function_t *__rehasher;
17273   } _va = {&_fbb, _o, _rehasher};
17274   (void)_va;
17275   auto _fused_activation_function = _o->fused_activation_function;
17276   auto _pot_scale_int16 = _o->pot_scale_int16;
17277   return circle::CreateSubOptions(_fbb, _fused_activation_function, _pot_scale_int16);
17278 }
17279
17280 inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17281 {
17282   auto _o = std::unique_ptr<DivOptionsT>(new DivOptionsT());
17283   UnPackTo(_o.get(), _resolver);
17284   return _o.release();
17285 }
17286
17287 inline void DivOptions::UnPackTo(DivOptionsT *_o,
17288                                  const flatbuffers::resolver_function_t *_resolver) const
17289 {
17290   (void)_o;
17291   (void)_resolver;
17292   {
17293     auto _e = fused_activation_function();
17294     _o->fused_activation_function = _e;
17295   }
17296 }
17297
17298 inline flatbuffers::Offset<DivOptions>
17299 DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o,
17300                  const flatbuffers::rehasher_function_t *_rehasher)
17301 {
17302   return CreateDivOptions(_fbb, _o, _rehasher);
17303 }
17304
17305 inline flatbuffers::Offset<DivOptions>
17306 CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o,
17307                  const flatbuffers::rehasher_function_t *_rehasher)
17308 {
17309   (void)_rehasher;
17310   (void)_o;
17311   struct _VectorArgs
17312   {
17313     flatbuffers::FlatBufferBuilder *__fbb;
17314     const DivOptionsT *__o;
17315     const flatbuffers::rehasher_function_t *__rehasher;
17316   } _va = {&_fbb, _o, _rehasher};
17317   (void)_va;
17318   auto _fused_activation_function = _o->fused_activation_function;
17319   return circle::CreateDivOptions(_fbb, _fused_activation_function);
17320 }
17321
17322 inline TopKV2OptionsT *
17323 TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17324 {
17325   auto _o = std::unique_ptr<TopKV2OptionsT>(new TopKV2OptionsT());
17326   UnPackTo(_o.get(), _resolver);
17327   return _o.release();
17328 }
17329
17330 inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o,
17331                                     const flatbuffers::resolver_function_t *_resolver) const
17332 {
17333   (void)_o;
17334   (void)_resolver;
17335 }
17336
17337 inline flatbuffers::Offset<TopKV2Options>
17338 TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o,
17339                     const flatbuffers::rehasher_function_t *_rehasher)
17340 {
17341   return CreateTopKV2Options(_fbb, _o, _rehasher);
17342 }
17343
17344 inline flatbuffers::Offset<TopKV2Options>
17345 CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o,
17346                     const flatbuffers::rehasher_function_t *_rehasher)
17347 {
17348   (void)_rehasher;
17349   (void)_o;
17350   struct _VectorArgs
17351   {
17352     flatbuffers::FlatBufferBuilder *__fbb;
17353     const TopKV2OptionsT *__o;
17354     const flatbuffers::rehasher_function_t *__rehasher;
17355   } _va = {&_fbb, _o, _rehasher};
17356   (void)_va;
17357   return circle::CreateTopKV2Options(_fbb);
17358 }
17359
17360 inline EmbeddingLookupSparseOptionsT *
17361 EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17362 {
17363   auto _o = std::unique_ptr<EmbeddingLookupSparseOptionsT>(new EmbeddingLookupSparseOptionsT());
17364   UnPackTo(_o.get(), _resolver);
17365   return _o.release();
17366 }
17367
17368 inline void
17369 EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o,
17370                                        const flatbuffers::resolver_function_t *_resolver) const
17371 {
17372   (void)_o;
17373   (void)_resolver;
17374   {
17375     auto _e = combiner();
17376     _o->combiner = _e;
17377   }
17378 }
17379
17380 inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
17381 EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
17382                                    const EmbeddingLookupSparseOptionsT *_o,
17383                                    const flatbuffers::rehasher_function_t *_rehasher)
17384 {
17385   return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
17386 }
17387
17388 inline flatbuffers::Offset<EmbeddingLookupSparseOptions>
17389 CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb,
17390                                    const EmbeddingLookupSparseOptionsT *_o,
17391                                    const flatbuffers::rehasher_function_t *_rehasher)
17392 {
17393   (void)_rehasher;
17394   (void)_o;
17395   struct _VectorArgs
17396   {
17397     flatbuffers::FlatBufferBuilder *__fbb;
17398     const EmbeddingLookupSparseOptionsT *__o;
17399     const flatbuffers::rehasher_function_t *__rehasher;
17400   } _va = {&_fbb, _o, _rehasher};
17401   (void)_va;
17402   auto _combiner = _o->combiner;
17403   return circle::CreateEmbeddingLookupSparseOptions(_fbb, _combiner);
17404 }
17405
17406 inline GatherOptionsT *
17407 GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17408 {
17409   auto _o = std::unique_ptr<GatherOptionsT>(new GatherOptionsT());
17410   UnPackTo(_o.get(), _resolver);
17411   return _o.release();
17412 }
17413
17414 inline void GatherOptions::UnPackTo(GatherOptionsT *_o,
17415                                     const flatbuffers::resolver_function_t *_resolver) const
17416 {
17417   (void)_o;
17418   (void)_resolver;
17419   {
17420     auto _e = axis();
17421     _o->axis = _e;
17422   }
17423   {
17424     auto _e = batch_dims();
17425     _o->batch_dims = _e;
17426   }
17427 }
17428
17429 inline flatbuffers::Offset<GatherOptions>
17430 GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o,
17431                     const flatbuffers::rehasher_function_t *_rehasher)
17432 {
17433   return CreateGatherOptions(_fbb, _o, _rehasher);
17434 }
17435
17436 inline flatbuffers::Offset<GatherOptions>
17437 CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o,
17438                     const flatbuffers::rehasher_function_t *_rehasher)
17439 {
17440   (void)_rehasher;
17441   (void)_o;
17442   struct _VectorArgs
17443   {
17444     flatbuffers::FlatBufferBuilder *__fbb;
17445     const GatherOptionsT *__o;
17446     const flatbuffers::rehasher_function_t *__rehasher;
17447   } _va = {&_fbb, _o, _rehasher};
17448   (void)_va;
17449   auto _axis = _o->axis;
17450   auto _batch_dims = _o->batch_dims;
17451   return circle::CreateGatherOptions(_fbb, _axis, _batch_dims);
17452 }
17453
17454 inline TransposeOptionsT *
17455 TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17456 {
17457   auto _o = std::unique_ptr<TransposeOptionsT>(new TransposeOptionsT());
17458   UnPackTo(_o.get(), _resolver);
17459   return _o.release();
17460 }
17461
17462 inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o,
17463                                        const flatbuffers::resolver_function_t *_resolver) const
17464 {
17465   (void)_o;
17466   (void)_resolver;
17467 }
17468
17469 inline flatbuffers::Offset<TransposeOptions>
17470 TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o,
17471                        const flatbuffers::rehasher_function_t *_rehasher)
17472 {
17473   return CreateTransposeOptions(_fbb, _o, _rehasher);
17474 }
17475
17476 inline flatbuffers::Offset<TransposeOptions>
17477 CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o,
17478                        const flatbuffers::rehasher_function_t *_rehasher)
17479 {
17480   (void)_rehasher;
17481   (void)_o;
17482   struct _VectorArgs
17483   {
17484     flatbuffers::FlatBufferBuilder *__fbb;
17485     const TransposeOptionsT *__o;
17486     const flatbuffers::rehasher_function_t *__rehasher;
17487   } _va = {&_fbb, _o, _rehasher};
17488   (void)_va;
17489   return circle::CreateTransposeOptions(_fbb);
17490 }
17491
17492 inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17493 {
17494   auto _o = std::unique_ptr<ExpOptionsT>(new ExpOptionsT());
17495   UnPackTo(_o.get(), _resolver);
17496   return _o.release();
17497 }
17498
17499 inline void ExpOptions::UnPackTo(ExpOptionsT *_o,
17500                                  const flatbuffers::resolver_function_t *_resolver) const
17501 {
17502   (void)_o;
17503   (void)_resolver;
17504 }
17505
17506 inline flatbuffers::Offset<ExpOptions>
17507 ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o,
17508                  const flatbuffers::rehasher_function_t *_rehasher)
17509 {
17510   return CreateExpOptions(_fbb, _o, _rehasher);
17511 }
17512
17513 inline flatbuffers::Offset<ExpOptions>
17514 CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o,
17515                  const flatbuffers::rehasher_function_t *_rehasher)
17516 {
17517   (void)_rehasher;
17518   (void)_o;
17519   struct _VectorArgs
17520   {
17521     flatbuffers::FlatBufferBuilder *__fbb;
17522     const ExpOptionsT *__o;
17523     const flatbuffers::rehasher_function_t *__rehasher;
17524   } _va = {&_fbb, _o, _rehasher};
17525   (void)_va;
17526   return circle::CreateExpOptions(_fbb);
17527 }
17528
17529 inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17530 {
17531   auto _o = std::unique_ptr<CosOptionsT>(new CosOptionsT());
17532   UnPackTo(_o.get(), _resolver);
17533   return _o.release();
17534 }
17535
17536 inline void CosOptions::UnPackTo(CosOptionsT *_o,
17537                                  const flatbuffers::resolver_function_t *_resolver) const
17538 {
17539   (void)_o;
17540   (void)_resolver;
17541 }
17542
17543 inline flatbuffers::Offset<CosOptions>
17544 CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o,
17545                  const flatbuffers::rehasher_function_t *_rehasher)
17546 {
17547   return CreateCosOptions(_fbb, _o, _rehasher);
17548 }
17549
17550 inline flatbuffers::Offset<CosOptions>
17551 CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o,
17552                  const flatbuffers::rehasher_function_t *_rehasher)
17553 {
17554   (void)_rehasher;
17555   (void)_o;
17556   struct _VectorArgs
17557   {
17558     flatbuffers::FlatBufferBuilder *__fbb;
17559     const CosOptionsT *__o;
17560     const flatbuffers::rehasher_function_t *__rehasher;
17561   } _va = {&_fbb, _o, _rehasher};
17562   (void)_va;
17563   return circle::CreateCosOptions(_fbb);
17564 }
17565
17566 inline ReducerOptionsT *
17567 ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17568 {
17569   auto _o = std::unique_ptr<ReducerOptionsT>(new ReducerOptionsT());
17570   UnPackTo(_o.get(), _resolver);
17571   return _o.release();
17572 }
17573
17574 inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o,
17575                                      const flatbuffers::resolver_function_t *_resolver) const
17576 {
17577   (void)_o;
17578   (void)_resolver;
17579   {
17580     auto _e = keep_dims();
17581     _o->keep_dims = _e;
17582   }
17583 }
17584
17585 inline flatbuffers::Offset<ReducerOptions>
17586 ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o,
17587                      const flatbuffers::rehasher_function_t *_rehasher)
17588 {
17589   return CreateReducerOptions(_fbb, _o, _rehasher);
17590 }
17591
17592 inline flatbuffers::Offset<ReducerOptions>
17593 CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o,
17594                      const flatbuffers::rehasher_function_t *_rehasher)
17595 {
17596   (void)_rehasher;
17597   (void)_o;
17598   struct _VectorArgs
17599   {
17600     flatbuffers::FlatBufferBuilder *__fbb;
17601     const ReducerOptionsT *__o;
17602     const flatbuffers::rehasher_function_t *__rehasher;
17603   } _va = {&_fbb, _o, _rehasher};
17604   (void)_va;
17605   auto _keep_dims = _o->keep_dims;
17606   return circle::CreateReducerOptions(_fbb, _keep_dims);
17607 }
17608
17609 inline SqueezeOptionsT *
17610 SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17611 {
17612   auto _o = std::unique_ptr<SqueezeOptionsT>(new SqueezeOptionsT());
17613   UnPackTo(_o.get(), _resolver);
17614   return _o.release();
17615 }
17616
17617 inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o,
17618                                      const flatbuffers::resolver_function_t *_resolver) const
17619 {
17620   (void)_o;
17621   (void)_resolver;
17622   {
17623     auto _e = squeeze_dims();
17624     if (_e)
17625     {
17626       _o->squeeze_dims.resize(_e->size());
17627       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
17628       {
17629         _o->squeeze_dims[_i] = _e->Get(_i);
17630       }
17631     }
17632   }
17633 }
17634
17635 inline flatbuffers::Offset<SqueezeOptions>
17636 SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o,
17637                      const flatbuffers::rehasher_function_t *_rehasher)
17638 {
17639   return CreateSqueezeOptions(_fbb, _o, _rehasher);
17640 }
17641
17642 inline flatbuffers::Offset<SqueezeOptions>
17643 CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o,
17644                      const flatbuffers::rehasher_function_t *_rehasher)
17645 {
17646   (void)_rehasher;
17647   (void)_o;
17648   struct _VectorArgs
17649   {
17650     flatbuffers::FlatBufferBuilder *__fbb;
17651     const SqueezeOptionsT *__o;
17652     const flatbuffers::rehasher_function_t *__rehasher;
17653   } _va = {&_fbb, _o, _rehasher};
17654   (void)_va;
17655   auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0;
17656   return circle::CreateSqueezeOptions(_fbb, _squeeze_dims);
17657 }
17658
17659 inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17660 {
17661   auto _o = std::unique_ptr<SplitOptionsT>(new SplitOptionsT());
17662   UnPackTo(_o.get(), _resolver);
17663   return _o.release();
17664 }
17665
17666 inline void SplitOptions::UnPackTo(SplitOptionsT *_o,
17667                                    const flatbuffers::resolver_function_t *_resolver) const
17668 {
17669   (void)_o;
17670   (void)_resolver;
17671   {
17672     auto _e = num_splits();
17673     _o->num_splits = _e;
17674   }
17675 }
17676
17677 inline flatbuffers::Offset<SplitOptions>
17678 SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o,
17679                    const flatbuffers::rehasher_function_t *_rehasher)
17680 {
17681   return CreateSplitOptions(_fbb, _o, _rehasher);
17682 }
17683
17684 inline flatbuffers::Offset<SplitOptions>
17685 CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o,
17686                    const flatbuffers::rehasher_function_t *_rehasher)
17687 {
17688   (void)_rehasher;
17689   (void)_o;
17690   struct _VectorArgs
17691   {
17692     flatbuffers::FlatBufferBuilder *__fbb;
17693     const SplitOptionsT *__o;
17694     const flatbuffers::rehasher_function_t *__rehasher;
17695   } _va = {&_fbb, _o, _rehasher};
17696   (void)_va;
17697   auto _num_splits = _o->num_splits;
17698   return circle::CreateSplitOptions(_fbb, _num_splits);
17699 }
17700
17701 inline SplitVOptionsT *
17702 SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17703 {
17704   auto _o = std::unique_ptr<SplitVOptionsT>(new SplitVOptionsT());
17705   UnPackTo(_o.get(), _resolver);
17706   return _o.release();
17707 }
17708
17709 inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o,
17710                                     const flatbuffers::resolver_function_t *_resolver) const
17711 {
17712   (void)_o;
17713   (void)_resolver;
17714   {
17715     auto _e = num_splits();
17716     _o->num_splits = _e;
17717   }
17718 }
17719
17720 inline flatbuffers::Offset<SplitVOptions>
17721 SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o,
17722                     const flatbuffers::rehasher_function_t *_rehasher)
17723 {
17724   return CreateSplitVOptions(_fbb, _o, _rehasher);
17725 }
17726
17727 inline flatbuffers::Offset<SplitVOptions>
17728 CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o,
17729                     const flatbuffers::rehasher_function_t *_rehasher)
17730 {
17731   (void)_rehasher;
17732   (void)_o;
17733   struct _VectorArgs
17734   {
17735     flatbuffers::FlatBufferBuilder *__fbb;
17736     const SplitVOptionsT *__o;
17737     const flatbuffers::rehasher_function_t *__rehasher;
17738   } _va = {&_fbb, _o, _rehasher};
17739   (void)_va;
17740   auto _num_splits = _o->num_splits;
17741   return circle::CreateSplitVOptions(_fbb, _num_splits);
17742 }
17743
17744 inline StridedSliceOptionsT *
17745 StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17746 {
17747   auto _o = std::unique_ptr<StridedSliceOptionsT>(new StridedSliceOptionsT());
17748   UnPackTo(_o.get(), _resolver);
17749   return _o.release();
17750 }
17751
17752 inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o,
17753                                           const flatbuffers::resolver_function_t *_resolver) const
17754 {
17755   (void)_o;
17756   (void)_resolver;
17757   {
17758     auto _e = begin_mask();
17759     _o->begin_mask = _e;
17760   }
17761   {
17762     auto _e = end_mask();
17763     _o->end_mask = _e;
17764   }
17765   {
17766     auto _e = ellipsis_mask();
17767     _o->ellipsis_mask = _e;
17768   }
17769   {
17770     auto _e = new_axis_mask();
17771     _o->new_axis_mask = _e;
17772   }
17773   {
17774     auto _e = shrink_axis_mask();
17775     _o->shrink_axis_mask = _e;
17776   }
17777 }
17778
17779 inline flatbuffers::Offset<StridedSliceOptions>
17780 StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o,
17781                           const flatbuffers::rehasher_function_t *_rehasher)
17782 {
17783   return CreateStridedSliceOptions(_fbb, _o, _rehasher);
17784 }
17785
17786 inline flatbuffers::Offset<StridedSliceOptions>
17787 CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o,
17788                           const flatbuffers::rehasher_function_t *_rehasher)
17789 {
17790   (void)_rehasher;
17791   (void)_o;
17792   struct _VectorArgs
17793   {
17794     flatbuffers::FlatBufferBuilder *__fbb;
17795     const StridedSliceOptionsT *__o;
17796     const flatbuffers::rehasher_function_t *__rehasher;
17797   } _va = {&_fbb, _o, _rehasher};
17798   (void)_va;
17799   auto _begin_mask = _o->begin_mask;
17800   auto _end_mask = _o->end_mask;
17801   auto _ellipsis_mask = _o->ellipsis_mask;
17802   auto _new_axis_mask = _o->new_axis_mask;
17803   auto _shrink_axis_mask = _o->shrink_axis_mask;
17804   return circle::CreateStridedSliceOptions(_fbb, _begin_mask, _end_mask, _ellipsis_mask,
17805                                            _new_axis_mask, _shrink_axis_mask);
17806 }
17807
17808 inline LogSoftmaxOptionsT *
17809 LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17810 {
17811   auto _o = std::unique_ptr<LogSoftmaxOptionsT>(new LogSoftmaxOptionsT());
17812   UnPackTo(_o.get(), _resolver);
17813   return _o.release();
17814 }
17815
17816 inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o,
17817                                         const flatbuffers::resolver_function_t *_resolver) const
17818 {
17819   (void)_o;
17820   (void)_resolver;
17821 }
17822
17823 inline flatbuffers::Offset<LogSoftmaxOptions>
17824 LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o,
17825                         const flatbuffers::rehasher_function_t *_rehasher)
17826 {
17827   return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
17828 }
17829
17830 inline flatbuffers::Offset<LogSoftmaxOptions>
17831 CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o,
17832                         const flatbuffers::rehasher_function_t *_rehasher)
17833 {
17834   (void)_rehasher;
17835   (void)_o;
17836   struct _VectorArgs
17837   {
17838     flatbuffers::FlatBufferBuilder *__fbb;
17839     const LogSoftmaxOptionsT *__o;
17840     const flatbuffers::rehasher_function_t *__rehasher;
17841   } _va = {&_fbb, _o, _rehasher};
17842   (void)_va;
17843   return circle::CreateLogSoftmaxOptions(_fbb);
17844 }
17845
17846 inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17847 {
17848   auto _o = std::unique_ptr<CastOptionsT>(new CastOptionsT());
17849   UnPackTo(_o.get(), _resolver);
17850   return _o.release();
17851 }
17852
17853 inline void CastOptions::UnPackTo(CastOptionsT *_o,
17854                                   const flatbuffers::resolver_function_t *_resolver) const
17855 {
17856   (void)_o;
17857   (void)_resolver;
17858   {
17859     auto _e = in_data_type();
17860     _o->in_data_type = _e;
17861   }
17862   {
17863     auto _e = out_data_type();
17864     _o->out_data_type = _e;
17865   }
17866 }
17867
17868 inline flatbuffers::Offset<CastOptions>
17869 CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o,
17870                   const flatbuffers::rehasher_function_t *_rehasher)
17871 {
17872   return CreateCastOptions(_fbb, _o, _rehasher);
17873 }
17874
17875 inline flatbuffers::Offset<CastOptions>
17876 CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o,
17877                   const flatbuffers::rehasher_function_t *_rehasher)
17878 {
17879   (void)_rehasher;
17880   (void)_o;
17881   struct _VectorArgs
17882   {
17883     flatbuffers::FlatBufferBuilder *__fbb;
17884     const CastOptionsT *__o;
17885     const flatbuffers::rehasher_function_t *__rehasher;
17886   } _va = {&_fbb, _o, _rehasher};
17887   (void)_va;
17888   auto _in_data_type = _o->in_data_type;
17889   auto _out_data_type = _o->out_data_type;
17890   return circle::CreateCastOptions(_fbb, _in_data_type, _out_data_type);
17891 }
17892
17893 inline DequantizeOptionsT *
17894 DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17895 {
17896   auto _o = std::unique_ptr<DequantizeOptionsT>(new DequantizeOptionsT());
17897   UnPackTo(_o.get(), _resolver);
17898   return _o.release();
17899 }
17900
17901 inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o,
17902                                         const flatbuffers::resolver_function_t *_resolver) const
17903 {
17904   (void)_o;
17905   (void)_resolver;
17906 }
17907
17908 inline flatbuffers::Offset<DequantizeOptions>
17909 DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o,
17910                         const flatbuffers::rehasher_function_t *_rehasher)
17911 {
17912   return CreateDequantizeOptions(_fbb, _o, _rehasher);
17913 }
17914
17915 inline flatbuffers::Offset<DequantizeOptions>
17916 CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o,
17917                         const flatbuffers::rehasher_function_t *_rehasher)
17918 {
17919   (void)_rehasher;
17920   (void)_o;
17921   struct _VectorArgs
17922   {
17923     flatbuffers::FlatBufferBuilder *__fbb;
17924     const DequantizeOptionsT *__o;
17925     const flatbuffers::rehasher_function_t *__rehasher;
17926   } _va = {&_fbb, _o, _rehasher};
17927   (void)_va;
17928   return circle::CreateDequantizeOptions(_fbb);
17929 }
17930
17931 inline MaximumMinimumOptionsT *
17932 MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17933 {
17934   auto _o = std::unique_ptr<MaximumMinimumOptionsT>(new MaximumMinimumOptionsT());
17935   UnPackTo(_o.get(), _resolver);
17936   return _o.release();
17937 }
17938
17939 inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o,
17940                                             const flatbuffers::resolver_function_t *_resolver) const
17941 {
17942   (void)_o;
17943   (void)_resolver;
17944 }
17945
17946 inline flatbuffers::Offset<MaximumMinimumOptions>
17947 MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o,
17948                             const flatbuffers::rehasher_function_t *_rehasher)
17949 {
17950   return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
17951 }
17952
17953 inline flatbuffers::Offset<MaximumMinimumOptions>
17954 CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o,
17955                             const flatbuffers::rehasher_function_t *_rehasher)
17956 {
17957   (void)_rehasher;
17958   (void)_o;
17959   struct _VectorArgs
17960   {
17961     flatbuffers::FlatBufferBuilder *__fbb;
17962     const MaximumMinimumOptionsT *__o;
17963     const flatbuffers::rehasher_function_t *__rehasher;
17964   } _va = {&_fbb, _o, _rehasher};
17965   (void)_va;
17966   return circle::CreateMaximumMinimumOptions(_fbb);
17967 }
17968
17969 inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
17970 {
17971   auto _o = std::unique_ptr<TileOptionsT>(new TileOptionsT());
17972   UnPackTo(_o.get(), _resolver);
17973   return _o.release();
17974 }
17975
17976 inline void TileOptions::UnPackTo(TileOptionsT *_o,
17977                                   const flatbuffers::resolver_function_t *_resolver) const
17978 {
17979   (void)_o;
17980   (void)_resolver;
17981 }
17982
17983 inline flatbuffers::Offset<TileOptions>
17984 TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o,
17985                   const flatbuffers::rehasher_function_t *_rehasher)
17986 {
17987   return CreateTileOptions(_fbb, _o, _rehasher);
17988 }
17989
17990 inline flatbuffers::Offset<TileOptions>
17991 CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o,
17992                   const flatbuffers::rehasher_function_t *_rehasher)
17993 {
17994   (void)_rehasher;
17995   (void)_o;
17996   struct _VectorArgs
17997   {
17998     flatbuffers::FlatBufferBuilder *__fbb;
17999     const TileOptionsT *__o;
18000     const flatbuffers::rehasher_function_t *__rehasher;
18001   } _va = {&_fbb, _o, _rehasher};
18002   (void)_va;
18003   return circle::CreateTileOptions(_fbb);
18004 }
18005
18006 inline ArgMaxOptionsT *
18007 ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18008 {
18009   auto _o = std::unique_ptr<ArgMaxOptionsT>(new ArgMaxOptionsT());
18010   UnPackTo(_o.get(), _resolver);
18011   return _o.release();
18012 }
18013
18014 inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o,
18015                                     const flatbuffers::resolver_function_t *_resolver) const
18016 {
18017   (void)_o;
18018   (void)_resolver;
18019   {
18020     auto _e = output_type();
18021     _o->output_type = _e;
18022   }
18023 }
18024
18025 inline flatbuffers::Offset<ArgMaxOptions>
18026 ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o,
18027                     const flatbuffers::rehasher_function_t *_rehasher)
18028 {
18029   return CreateArgMaxOptions(_fbb, _o, _rehasher);
18030 }
18031
18032 inline flatbuffers::Offset<ArgMaxOptions>
18033 CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o,
18034                     const flatbuffers::rehasher_function_t *_rehasher)
18035 {
18036   (void)_rehasher;
18037   (void)_o;
18038   struct _VectorArgs
18039   {
18040     flatbuffers::FlatBufferBuilder *__fbb;
18041     const ArgMaxOptionsT *__o;
18042     const flatbuffers::rehasher_function_t *__rehasher;
18043   } _va = {&_fbb, _o, _rehasher};
18044   (void)_va;
18045   auto _output_type = _o->output_type;
18046   return circle::CreateArgMaxOptions(_fbb, _output_type);
18047 }
18048
18049 inline ArgMinOptionsT *
18050 ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18051 {
18052   auto _o = std::unique_ptr<ArgMinOptionsT>(new ArgMinOptionsT());
18053   UnPackTo(_o.get(), _resolver);
18054   return _o.release();
18055 }
18056
18057 inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o,
18058                                     const flatbuffers::resolver_function_t *_resolver) const
18059 {
18060   (void)_o;
18061   (void)_resolver;
18062   {
18063     auto _e = output_type();
18064     _o->output_type = _e;
18065   }
18066 }
18067
18068 inline flatbuffers::Offset<ArgMinOptions>
18069 ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o,
18070                     const flatbuffers::rehasher_function_t *_rehasher)
18071 {
18072   return CreateArgMinOptions(_fbb, _o, _rehasher);
18073 }
18074
18075 inline flatbuffers::Offset<ArgMinOptions>
18076 CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o,
18077                     const flatbuffers::rehasher_function_t *_rehasher)
18078 {
18079   (void)_rehasher;
18080   (void)_o;
18081   struct _VectorArgs
18082   {
18083     flatbuffers::FlatBufferBuilder *__fbb;
18084     const ArgMinOptionsT *__o;
18085     const flatbuffers::rehasher_function_t *__rehasher;
18086   } _va = {&_fbb, _o, _rehasher};
18087   (void)_va;
18088   auto _output_type = _o->output_type;
18089   return circle::CreateArgMinOptions(_fbb, _output_type);
18090 }
18091
18092 inline GreaterOptionsT *
18093 GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18094 {
18095   auto _o = std::unique_ptr<GreaterOptionsT>(new GreaterOptionsT());
18096   UnPackTo(_o.get(), _resolver);
18097   return _o.release();
18098 }
18099
18100 inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o,
18101                                      const flatbuffers::resolver_function_t *_resolver) const
18102 {
18103   (void)_o;
18104   (void)_resolver;
18105 }
18106
18107 inline flatbuffers::Offset<GreaterOptions>
18108 GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o,
18109                      const flatbuffers::rehasher_function_t *_rehasher)
18110 {
18111   return CreateGreaterOptions(_fbb, _o, _rehasher);
18112 }
18113
18114 inline flatbuffers::Offset<GreaterOptions>
18115 CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o,
18116                      const flatbuffers::rehasher_function_t *_rehasher)
18117 {
18118   (void)_rehasher;
18119   (void)_o;
18120   struct _VectorArgs
18121   {
18122     flatbuffers::FlatBufferBuilder *__fbb;
18123     const GreaterOptionsT *__o;
18124     const flatbuffers::rehasher_function_t *__rehasher;
18125   } _va = {&_fbb, _o, _rehasher};
18126   (void)_va;
18127   return circle::CreateGreaterOptions(_fbb);
18128 }
18129
18130 inline GreaterEqualOptionsT *
18131 GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18132 {
18133   auto _o = std::unique_ptr<GreaterEqualOptionsT>(new GreaterEqualOptionsT());
18134   UnPackTo(_o.get(), _resolver);
18135   return _o.release();
18136 }
18137
18138 inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o,
18139                                           const flatbuffers::resolver_function_t *_resolver) const
18140 {
18141   (void)_o;
18142   (void)_resolver;
18143 }
18144
18145 inline flatbuffers::Offset<GreaterEqualOptions>
18146 GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o,
18147                           const flatbuffers::rehasher_function_t *_rehasher)
18148 {
18149   return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
18150 }
18151
18152 inline flatbuffers::Offset<GreaterEqualOptions>
18153 CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o,
18154                           const flatbuffers::rehasher_function_t *_rehasher)
18155 {
18156   (void)_rehasher;
18157   (void)_o;
18158   struct _VectorArgs
18159   {
18160     flatbuffers::FlatBufferBuilder *__fbb;
18161     const GreaterEqualOptionsT *__o;
18162     const flatbuffers::rehasher_function_t *__rehasher;
18163   } _va = {&_fbb, _o, _rehasher};
18164   (void)_va;
18165   return circle::CreateGreaterEqualOptions(_fbb);
18166 }
18167
18168 inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18169 {
18170   auto _o = std::unique_ptr<LessOptionsT>(new LessOptionsT());
18171   UnPackTo(_o.get(), _resolver);
18172   return _o.release();
18173 }
18174
18175 inline void LessOptions::UnPackTo(LessOptionsT *_o,
18176                                   const flatbuffers::resolver_function_t *_resolver) const
18177 {
18178   (void)_o;
18179   (void)_resolver;
18180 }
18181
18182 inline flatbuffers::Offset<LessOptions>
18183 LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o,
18184                   const flatbuffers::rehasher_function_t *_rehasher)
18185 {
18186   return CreateLessOptions(_fbb, _o, _rehasher);
18187 }
18188
18189 inline flatbuffers::Offset<LessOptions>
18190 CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o,
18191                   const flatbuffers::rehasher_function_t *_rehasher)
18192 {
18193   (void)_rehasher;
18194   (void)_o;
18195   struct _VectorArgs
18196   {
18197     flatbuffers::FlatBufferBuilder *__fbb;
18198     const LessOptionsT *__o;
18199     const flatbuffers::rehasher_function_t *__rehasher;
18200   } _va = {&_fbb, _o, _rehasher};
18201   (void)_va;
18202   return circle::CreateLessOptions(_fbb);
18203 }
18204
18205 inline LessEqualOptionsT *
18206 LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18207 {
18208   auto _o = std::unique_ptr<LessEqualOptionsT>(new LessEqualOptionsT());
18209   UnPackTo(_o.get(), _resolver);
18210   return _o.release();
18211 }
18212
18213 inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o,
18214                                        const flatbuffers::resolver_function_t *_resolver) const
18215 {
18216   (void)_o;
18217   (void)_resolver;
18218 }
18219
18220 inline flatbuffers::Offset<LessEqualOptions>
18221 LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o,
18222                        const flatbuffers::rehasher_function_t *_rehasher)
18223 {
18224   return CreateLessEqualOptions(_fbb, _o, _rehasher);
18225 }
18226
18227 inline flatbuffers::Offset<LessEqualOptions>
18228 CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o,
18229                        const flatbuffers::rehasher_function_t *_rehasher)
18230 {
18231   (void)_rehasher;
18232   (void)_o;
18233   struct _VectorArgs
18234   {
18235     flatbuffers::FlatBufferBuilder *__fbb;
18236     const LessEqualOptionsT *__o;
18237     const flatbuffers::rehasher_function_t *__rehasher;
18238   } _va = {&_fbb, _o, _rehasher};
18239   (void)_va;
18240   return circle::CreateLessEqualOptions(_fbb);
18241 }
18242
18243 inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18244 {
18245   auto _o = std::unique_ptr<NegOptionsT>(new NegOptionsT());
18246   UnPackTo(_o.get(), _resolver);
18247   return _o.release();
18248 }
18249
18250 inline void NegOptions::UnPackTo(NegOptionsT *_o,
18251                                  const flatbuffers::resolver_function_t *_resolver) const
18252 {
18253   (void)_o;
18254   (void)_resolver;
18255 }
18256
18257 inline flatbuffers::Offset<NegOptions>
18258 NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o,
18259                  const flatbuffers::rehasher_function_t *_rehasher)
18260 {
18261   return CreateNegOptions(_fbb, _o, _rehasher);
18262 }
18263
18264 inline flatbuffers::Offset<NegOptions>
18265 CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o,
18266                  const flatbuffers::rehasher_function_t *_rehasher)
18267 {
18268   (void)_rehasher;
18269   (void)_o;
18270   struct _VectorArgs
18271   {
18272     flatbuffers::FlatBufferBuilder *__fbb;
18273     const NegOptionsT *__o;
18274     const flatbuffers::rehasher_function_t *__rehasher;
18275   } _va = {&_fbb, _o, _rehasher};
18276   (void)_va;
18277   return circle::CreateNegOptions(_fbb);
18278 }
18279
18280 inline SelectOptionsT *
18281 SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18282 {
18283   auto _o = std::unique_ptr<SelectOptionsT>(new SelectOptionsT());
18284   UnPackTo(_o.get(), _resolver);
18285   return _o.release();
18286 }
18287
18288 inline void SelectOptions::UnPackTo(SelectOptionsT *_o,
18289                                     const flatbuffers::resolver_function_t *_resolver) const
18290 {
18291   (void)_o;
18292   (void)_resolver;
18293 }
18294
18295 inline flatbuffers::Offset<SelectOptions>
18296 SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o,
18297                     const flatbuffers::rehasher_function_t *_rehasher)
18298 {
18299   return CreateSelectOptions(_fbb, _o, _rehasher);
18300 }
18301
18302 inline flatbuffers::Offset<SelectOptions>
18303 CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o,
18304                     const flatbuffers::rehasher_function_t *_rehasher)
18305 {
18306   (void)_rehasher;
18307   (void)_o;
18308   struct _VectorArgs
18309   {
18310     flatbuffers::FlatBufferBuilder *__fbb;
18311     const SelectOptionsT *__o;
18312     const flatbuffers::rehasher_function_t *__rehasher;
18313   } _va = {&_fbb, _o, _rehasher};
18314   (void)_va;
18315   return circle::CreateSelectOptions(_fbb);
18316 }
18317
18318 inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18319 {
18320   auto _o = std::unique_ptr<SliceOptionsT>(new SliceOptionsT());
18321   UnPackTo(_o.get(), _resolver);
18322   return _o.release();
18323 }
18324
18325 inline void SliceOptions::UnPackTo(SliceOptionsT *_o,
18326                                    const flatbuffers::resolver_function_t *_resolver) const
18327 {
18328   (void)_o;
18329   (void)_resolver;
18330 }
18331
18332 inline flatbuffers::Offset<SliceOptions>
18333 SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o,
18334                    const flatbuffers::rehasher_function_t *_rehasher)
18335 {
18336   return CreateSliceOptions(_fbb, _o, _rehasher);
18337 }
18338
18339 inline flatbuffers::Offset<SliceOptions>
18340 CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o,
18341                    const flatbuffers::rehasher_function_t *_rehasher)
18342 {
18343   (void)_rehasher;
18344   (void)_o;
18345   struct _VectorArgs
18346   {
18347     flatbuffers::FlatBufferBuilder *__fbb;
18348     const SliceOptionsT *__o;
18349     const flatbuffers::rehasher_function_t *__rehasher;
18350   } _va = {&_fbb, _o, _rehasher};
18351   (void)_va;
18352   return circle::CreateSliceOptions(_fbb);
18353 }
18354
18355 inline TransposeConvOptionsT *
18356 TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18357 {
18358   auto _o = std::unique_ptr<TransposeConvOptionsT>(new TransposeConvOptionsT());
18359   UnPackTo(_o.get(), _resolver);
18360   return _o.release();
18361 }
18362
18363 inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o,
18364                                            const flatbuffers::resolver_function_t *_resolver) const
18365 {
18366   (void)_o;
18367   (void)_resolver;
18368   {
18369     auto _e = padding();
18370     _o->padding = _e;
18371   }
18372   {
18373     auto _e = stride_w();
18374     _o->stride_w = _e;
18375   }
18376   {
18377     auto _e = stride_h();
18378     _o->stride_h = _e;
18379   }
18380 }
18381
18382 inline flatbuffers::Offset<TransposeConvOptions>
18383 TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o,
18384                            const flatbuffers::rehasher_function_t *_rehasher)
18385 {
18386   return CreateTransposeConvOptions(_fbb, _o, _rehasher);
18387 }
18388
18389 inline flatbuffers::Offset<TransposeConvOptions>
18390 CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o,
18391                            const flatbuffers::rehasher_function_t *_rehasher)
18392 {
18393   (void)_rehasher;
18394   (void)_o;
18395   struct _VectorArgs
18396   {
18397     flatbuffers::FlatBufferBuilder *__fbb;
18398     const TransposeConvOptionsT *__o;
18399     const flatbuffers::rehasher_function_t *__rehasher;
18400   } _va = {&_fbb, _o, _rehasher};
18401   (void)_va;
18402   auto _padding = _o->padding;
18403   auto _stride_w = _o->stride_w;
18404   auto _stride_h = _o->stride_h;
18405   return circle::CreateTransposeConvOptions(_fbb, _padding, _stride_w, _stride_h);
18406 }
18407
18408 inline ExpandDimsOptionsT *
18409 ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18410 {
18411   auto _o = std::unique_ptr<ExpandDimsOptionsT>(new ExpandDimsOptionsT());
18412   UnPackTo(_o.get(), _resolver);
18413   return _o.release();
18414 }
18415
18416 inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o,
18417                                         const flatbuffers::resolver_function_t *_resolver) const
18418 {
18419   (void)_o;
18420   (void)_resolver;
18421 }
18422
18423 inline flatbuffers::Offset<ExpandDimsOptions>
18424 ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o,
18425                         const flatbuffers::rehasher_function_t *_rehasher)
18426 {
18427   return CreateExpandDimsOptions(_fbb, _o, _rehasher);
18428 }
18429
18430 inline flatbuffers::Offset<ExpandDimsOptions>
18431 CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o,
18432                         const flatbuffers::rehasher_function_t *_rehasher)
18433 {
18434   (void)_rehasher;
18435   (void)_o;
18436   struct _VectorArgs
18437   {
18438     flatbuffers::FlatBufferBuilder *__fbb;
18439     const ExpandDimsOptionsT *__o;
18440     const flatbuffers::rehasher_function_t *__rehasher;
18441   } _va = {&_fbb, _o, _rehasher};
18442   (void)_va;
18443   return circle::CreateExpandDimsOptions(_fbb);
18444 }
18445
18446 inline SparseToDenseOptionsT *
18447 SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18448 {
18449   auto _o = std::unique_ptr<SparseToDenseOptionsT>(new SparseToDenseOptionsT());
18450   UnPackTo(_o.get(), _resolver);
18451   return _o.release();
18452 }
18453
18454 inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o,
18455                                            const flatbuffers::resolver_function_t *_resolver) const
18456 {
18457   (void)_o;
18458   (void)_resolver;
18459   {
18460     auto _e = validate_indices();
18461     _o->validate_indices = _e;
18462   }
18463 }
18464
18465 inline flatbuffers::Offset<SparseToDenseOptions>
18466 SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o,
18467                            const flatbuffers::rehasher_function_t *_rehasher)
18468 {
18469   return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
18470 }
18471
18472 inline flatbuffers::Offset<SparseToDenseOptions>
18473 CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o,
18474                            const flatbuffers::rehasher_function_t *_rehasher)
18475 {
18476   (void)_rehasher;
18477   (void)_o;
18478   struct _VectorArgs
18479   {
18480     flatbuffers::FlatBufferBuilder *__fbb;
18481     const SparseToDenseOptionsT *__o;
18482     const flatbuffers::rehasher_function_t *__rehasher;
18483   } _va = {&_fbb, _o, _rehasher};
18484   (void)_va;
18485   auto _validate_indices = _o->validate_indices;
18486   return circle::CreateSparseToDenseOptions(_fbb, _validate_indices);
18487 }
18488
18489 inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18490 {
18491   auto _o = std::unique_ptr<EqualOptionsT>(new EqualOptionsT());
18492   UnPackTo(_o.get(), _resolver);
18493   return _o.release();
18494 }
18495
18496 inline void EqualOptions::UnPackTo(EqualOptionsT *_o,
18497                                    const flatbuffers::resolver_function_t *_resolver) const
18498 {
18499   (void)_o;
18500   (void)_resolver;
18501 }
18502
18503 inline flatbuffers::Offset<EqualOptions>
18504 EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o,
18505                    const flatbuffers::rehasher_function_t *_rehasher)
18506 {
18507   return CreateEqualOptions(_fbb, _o, _rehasher);
18508 }
18509
18510 inline flatbuffers::Offset<EqualOptions>
18511 CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o,
18512                    const flatbuffers::rehasher_function_t *_rehasher)
18513 {
18514   (void)_rehasher;
18515   (void)_o;
18516   struct _VectorArgs
18517   {
18518     flatbuffers::FlatBufferBuilder *__fbb;
18519     const EqualOptionsT *__o;
18520     const flatbuffers::rehasher_function_t *__rehasher;
18521   } _va = {&_fbb, _o, _rehasher};
18522   (void)_va;
18523   return circle::CreateEqualOptions(_fbb);
18524 }
18525
18526 inline NotEqualOptionsT *
18527 NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18528 {
18529   auto _o = std::unique_ptr<NotEqualOptionsT>(new NotEqualOptionsT());
18530   UnPackTo(_o.get(), _resolver);
18531   return _o.release();
18532 }
18533
18534 inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o,
18535                                       const flatbuffers::resolver_function_t *_resolver) const
18536 {
18537   (void)_o;
18538   (void)_resolver;
18539 }
18540
18541 inline flatbuffers::Offset<NotEqualOptions>
18542 NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o,
18543                       const flatbuffers::rehasher_function_t *_rehasher)
18544 {
18545   return CreateNotEqualOptions(_fbb, _o, _rehasher);
18546 }
18547
18548 inline flatbuffers::Offset<NotEqualOptions>
18549 CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o,
18550                       const flatbuffers::rehasher_function_t *_rehasher)
18551 {
18552   (void)_rehasher;
18553   (void)_o;
18554   struct _VectorArgs
18555   {
18556     flatbuffers::FlatBufferBuilder *__fbb;
18557     const NotEqualOptionsT *__o;
18558     const flatbuffers::rehasher_function_t *__rehasher;
18559   } _va = {&_fbb, _o, _rehasher};
18560   (void)_va;
18561   return circle::CreateNotEqualOptions(_fbb);
18562 }
18563
18564 inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18565 {
18566   auto _o = std::unique_ptr<ShapeOptionsT>(new ShapeOptionsT());
18567   UnPackTo(_o.get(), _resolver);
18568   return _o.release();
18569 }
18570
18571 inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o,
18572                                    const flatbuffers::resolver_function_t *_resolver) const
18573 {
18574   (void)_o;
18575   (void)_resolver;
18576   {
18577     auto _e = out_type();
18578     _o->out_type = _e;
18579   }
18580 }
18581
18582 inline flatbuffers::Offset<ShapeOptions>
18583 ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o,
18584                    const flatbuffers::rehasher_function_t *_rehasher)
18585 {
18586   return CreateShapeOptions(_fbb, _o, _rehasher);
18587 }
18588
18589 inline flatbuffers::Offset<ShapeOptions>
18590 CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o,
18591                    const flatbuffers::rehasher_function_t *_rehasher)
18592 {
18593   (void)_rehasher;
18594   (void)_o;
18595   struct _VectorArgs
18596   {
18597     flatbuffers::FlatBufferBuilder *__fbb;
18598     const ShapeOptionsT *__o;
18599     const flatbuffers::rehasher_function_t *__rehasher;
18600   } _va = {&_fbb, _o, _rehasher};
18601   (void)_va;
18602   auto _out_type = _o->out_type;
18603   return circle::CreateShapeOptions(_fbb, _out_type);
18604 }
18605
18606 inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18607 {
18608   auto _o = std::unique_ptr<RankOptionsT>(new RankOptionsT());
18609   UnPackTo(_o.get(), _resolver);
18610   return _o.release();
18611 }
18612
18613 inline void RankOptions::UnPackTo(RankOptionsT *_o,
18614                                   const flatbuffers::resolver_function_t *_resolver) const
18615 {
18616   (void)_o;
18617   (void)_resolver;
18618 }
18619
18620 inline flatbuffers::Offset<RankOptions>
18621 RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o,
18622                   const flatbuffers::rehasher_function_t *_rehasher)
18623 {
18624   return CreateRankOptions(_fbb, _o, _rehasher);
18625 }
18626
18627 inline flatbuffers::Offset<RankOptions>
18628 CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o,
18629                   const flatbuffers::rehasher_function_t *_rehasher)
18630 {
18631   (void)_rehasher;
18632   (void)_o;
18633   struct _VectorArgs
18634   {
18635     flatbuffers::FlatBufferBuilder *__fbb;
18636     const RankOptionsT *__o;
18637     const flatbuffers::rehasher_function_t *__rehasher;
18638   } _va = {&_fbb, _o, _rehasher};
18639   (void)_va;
18640   return circle::CreateRankOptions(_fbb);
18641 }
18642
18643 inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18644 {
18645   auto _o = std::unique_ptr<PowOptionsT>(new PowOptionsT());
18646   UnPackTo(_o.get(), _resolver);
18647   return _o.release();
18648 }
18649
18650 inline void PowOptions::UnPackTo(PowOptionsT *_o,
18651                                  const flatbuffers::resolver_function_t *_resolver) const
18652 {
18653   (void)_o;
18654   (void)_resolver;
18655 }
18656
18657 inline flatbuffers::Offset<PowOptions>
18658 PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o,
18659                  const flatbuffers::rehasher_function_t *_rehasher)
18660 {
18661   return CreatePowOptions(_fbb, _o, _rehasher);
18662 }
18663
18664 inline flatbuffers::Offset<PowOptions>
18665 CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o,
18666                  const flatbuffers::rehasher_function_t *_rehasher)
18667 {
18668   (void)_rehasher;
18669   (void)_o;
18670   struct _VectorArgs
18671   {
18672     flatbuffers::FlatBufferBuilder *__fbb;
18673     const PowOptionsT *__o;
18674     const flatbuffers::rehasher_function_t *__rehasher;
18675   } _va = {&_fbb, _o, _rehasher};
18676   (void)_va;
18677   return circle::CreatePowOptions(_fbb);
18678 }
18679
18680 inline FakeQuantOptionsT *
18681 FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18682 {
18683   auto _o = std::unique_ptr<FakeQuantOptionsT>(new FakeQuantOptionsT());
18684   UnPackTo(_o.get(), _resolver);
18685   return _o.release();
18686 }
18687
18688 inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o,
18689                                        const flatbuffers::resolver_function_t *_resolver) const
18690 {
18691   (void)_o;
18692   (void)_resolver;
18693   {
18694     auto _e = min();
18695     _o->min = _e;
18696   }
18697   {
18698     auto _e = max();
18699     _o->max = _e;
18700   }
18701   {
18702     auto _e = num_bits();
18703     _o->num_bits = _e;
18704   }
18705   {
18706     auto _e = narrow_range();
18707     _o->narrow_range = _e;
18708   }
18709 }
18710
18711 inline flatbuffers::Offset<FakeQuantOptions>
18712 FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o,
18713                        const flatbuffers::rehasher_function_t *_rehasher)
18714 {
18715   return CreateFakeQuantOptions(_fbb, _o, _rehasher);
18716 }
18717
18718 inline flatbuffers::Offset<FakeQuantOptions>
18719 CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o,
18720                        const flatbuffers::rehasher_function_t *_rehasher)
18721 {
18722   (void)_rehasher;
18723   (void)_o;
18724   struct _VectorArgs
18725   {
18726     flatbuffers::FlatBufferBuilder *__fbb;
18727     const FakeQuantOptionsT *__o;
18728     const flatbuffers::rehasher_function_t *__rehasher;
18729   } _va = {&_fbb, _o, _rehasher};
18730   (void)_va;
18731   auto _min = _o->min;
18732   auto _max = _o->max;
18733   auto _num_bits = _o->num_bits;
18734   auto _narrow_range = _o->narrow_range;
18735   return circle::CreateFakeQuantOptions(_fbb, _min, _max, _num_bits, _narrow_range);
18736 }
18737
18738 inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18739 {
18740   auto _o = std::unique_ptr<PackOptionsT>(new PackOptionsT());
18741   UnPackTo(_o.get(), _resolver);
18742   return _o.release();
18743 }
18744
18745 inline void PackOptions::UnPackTo(PackOptionsT *_o,
18746                                   const flatbuffers::resolver_function_t *_resolver) const
18747 {
18748   (void)_o;
18749   (void)_resolver;
18750   {
18751     auto _e = values_count();
18752     _o->values_count = _e;
18753   }
18754   {
18755     auto _e = axis();
18756     _o->axis = _e;
18757   }
18758 }
18759
18760 inline flatbuffers::Offset<PackOptions>
18761 PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o,
18762                   const flatbuffers::rehasher_function_t *_rehasher)
18763 {
18764   return CreatePackOptions(_fbb, _o, _rehasher);
18765 }
18766
18767 inline flatbuffers::Offset<PackOptions>
18768 CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o,
18769                   const flatbuffers::rehasher_function_t *_rehasher)
18770 {
18771   (void)_rehasher;
18772   (void)_o;
18773   struct _VectorArgs
18774   {
18775     flatbuffers::FlatBufferBuilder *__fbb;
18776     const PackOptionsT *__o;
18777     const flatbuffers::rehasher_function_t *__rehasher;
18778   } _va = {&_fbb, _o, _rehasher};
18779   (void)_va;
18780   auto _values_count = _o->values_count;
18781   auto _axis = _o->axis;
18782   return circle::CreatePackOptions(_fbb, _values_count, _axis);
18783 }
18784
18785 inline LogicalOrOptionsT *
18786 LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18787 {
18788   auto _o = std::unique_ptr<LogicalOrOptionsT>(new LogicalOrOptionsT());
18789   UnPackTo(_o.get(), _resolver);
18790   return _o.release();
18791 }
18792
18793 inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o,
18794                                        const flatbuffers::resolver_function_t *_resolver) const
18795 {
18796   (void)_o;
18797   (void)_resolver;
18798 }
18799
18800 inline flatbuffers::Offset<LogicalOrOptions>
18801 LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o,
18802                        const flatbuffers::rehasher_function_t *_rehasher)
18803 {
18804   return CreateLogicalOrOptions(_fbb, _o, _rehasher);
18805 }
18806
18807 inline flatbuffers::Offset<LogicalOrOptions>
18808 CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o,
18809                        const flatbuffers::rehasher_function_t *_rehasher)
18810 {
18811   (void)_rehasher;
18812   (void)_o;
18813   struct _VectorArgs
18814   {
18815     flatbuffers::FlatBufferBuilder *__fbb;
18816     const LogicalOrOptionsT *__o;
18817     const flatbuffers::rehasher_function_t *__rehasher;
18818   } _va = {&_fbb, _o, _rehasher};
18819   (void)_va;
18820   return circle::CreateLogicalOrOptions(_fbb);
18821 }
18822
18823 inline OneHotOptionsT *
18824 OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18825 {
18826   auto _o = std::unique_ptr<OneHotOptionsT>(new OneHotOptionsT());
18827   UnPackTo(_o.get(), _resolver);
18828   return _o.release();
18829 }
18830
18831 inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o,
18832                                     const flatbuffers::resolver_function_t *_resolver) const
18833 {
18834   (void)_o;
18835   (void)_resolver;
18836   {
18837     auto _e = axis();
18838     _o->axis = _e;
18839   }
18840 }
18841
18842 inline flatbuffers::Offset<OneHotOptions>
18843 OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o,
18844                     const flatbuffers::rehasher_function_t *_rehasher)
18845 {
18846   return CreateOneHotOptions(_fbb, _o, _rehasher);
18847 }
18848
18849 inline flatbuffers::Offset<OneHotOptions>
18850 CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o,
18851                     const flatbuffers::rehasher_function_t *_rehasher)
18852 {
18853   (void)_rehasher;
18854   (void)_o;
18855   struct _VectorArgs
18856   {
18857     flatbuffers::FlatBufferBuilder *__fbb;
18858     const OneHotOptionsT *__o;
18859     const flatbuffers::rehasher_function_t *__rehasher;
18860   } _va = {&_fbb, _o, _rehasher};
18861   (void)_va;
18862   auto _axis = _o->axis;
18863   return circle::CreateOneHotOptions(_fbb, _axis);
18864 }
18865
18866 inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18867 {
18868   auto _o = std::unique_ptr<AbsOptionsT>(new AbsOptionsT());
18869   UnPackTo(_o.get(), _resolver);
18870   return _o.release();
18871 }
18872
18873 inline void AbsOptions::UnPackTo(AbsOptionsT *_o,
18874                                  const flatbuffers::resolver_function_t *_resolver) const
18875 {
18876   (void)_o;
18877   (void)_resolver;
18878 }
18879
18880 inline flatbuffers::Offset<AbsOptions>
18881 AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o,
18882                  const flatbuffers::rehasher_function_t *_rehasher)
18883 {
18884   return CreateAbsOptions(_fbb, _o, _rehasher);
18885 }
18886
18887 inline flatbuffers::Offset<AbsOptions>
18888 CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o,
18889                  const flatbuffers::rehasher_function_t *_rehasher)
18890 {
18891   (void)_rehasher;
18892   (void)_o;
18893   struct _VectorArgs
18894   {
18895     flatbuffers::FlatBufferBuilder *__fbb;
18896     const AbsOptionsT *__o;
18897     const flatbuffers::rehasher_function_t *__rehasher;
18898   } _va = {&_fbb, _o, _rehasher};
18899   (void)_va;
18900   return circle::CreateAbsOptions(_fbb);
18901 }
18902
18903 inline HardSwishOptionsT *
18904 HardSwishOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18905 {
18906   auto _o = std::unique_ptr<HardSwishOptionsT>(new HardSwishOptionsT());
18907   UnPackTo(_o.get(), _resolver);
18908   return _o.release();
18909 }
18910
18911 inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o,
18912                                        const flatbuffers::resolver_function_t *_resolver) const
18913 {
18914   (void)_o;
18915   (void)_resolver;
18916 }
18917
18918 inline flatbuffers::Offset<HardSwishOptions>
18919 HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o,
18920                        const flatbuffers::rehasher_function_t *_rehasher)
18921 {
18922   return CreateHardSwishOptions(_fbb, _o, _rehasher);
18923 }
18924
18925 inline flatbuffers::Offset<HardSwishOptions>
18926 CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o,
18927                        const flatbuffers::rehasher_function_t *_rehasher)
18928 {
18929   (void)_rehasher;
18930   (void)_o;
18931   struct _VectorArgs
18932   {
18933     flatbuffers::FlatBufferBuilder *__fbb;
18934     const HardSwishOptionsT *__o;
18935     const flatbuffers::rehasher_function_t *__rehasher;
18936   } _va = {&_fbb, _o, _rehasher};
18937   (void)_va;
18938   return circle::CreateHardSwishOptions(_fbb);
18939 }
18940
18941 inline LogicalAndOptionsT *
18942 LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18943 {
18944   auto _o = std::unique_ptr<LogicalAndOptionsT>(new LogicalAndOptionsT());
18945   UnPackTo(_o.get(), _resolver);
18946   return _o.release();
18947 }
18948
18949 inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o,
18950                                         const flatbuffers::resolver_function_t *_resolver) const
18951 {
18952   (void)_o;
18953   (void)_resolver;
18954 }
18955
18956 inline flatbuffers::Offset<LogicalAndOptions>
18957 LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o,
18958                         const flatbuffers::rehasher_function_t *_rehasher)
18959 {
18960   return CreateLogicalAndOptions(_fbb, _o, _rehasher);
18961 }
18962
18963 inline flatbuffers::Offset<LogicalAndOptions>
18964 CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o,
18965                         const flatbuffers::rehasher_function_t *_rehasher)
18966 {
18967   (void)_rehasher;
18968   (void)_o;
18969   struct _VectorArgs
18970   {
18971     flatbuffers::FlatBufferBuilder *__fbb;
18972     const LogicalAndOptionsT *__o;
18973     const flatbuffers::rehasher_function_t *__rehasher;
18974   } _va = {&_fbb, _o, _rehasher};
18975   (void)_va;
18976   return circle::CreateLogicalAndOptions(_fbb);
18977 }
18978
18979 inline LogicalNotOptionsT *
18980 LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
18981 {
18982   auto _o = std::unique_ptr<LogicalNotOptionsT>(new LogicalNotOptionsT());
18983   UnPackTo(_o.get(), _resolver);
18984   return _o.release();
18985 }
18986
18987 inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o,
18988                                         const flatbuffers::resolver_function_t *_resolver) const
18989 {
18990   (void)_o;
18991   (void)_resolver;
18992 }
18993
18994 inline flatbuffers::Offset<LogicalNotOptions>
18995 LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o,
18996                         const flatbuffers::rehasher_function_t *_rehasher)
18997 {
18998   return CreateLogicalNotOptions(_fbb, _o, _rehasher);
18999 }
19000
19001 inline flatbuffers::Offset<LogicalNotOptions>
19002 CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o,
19003                         const flatbuffers::rehasher_function_t *_rehasher)
19004 {
19005   (void)_rehasher;
19006   (void)_o;
19007   struct _VectorArgs
19008   {
19009     flatbuffers::FlatBufferBuilder *__fbb;
19010     const LogicalNotOptionsT *__o;
19011     const flatbuffers::rehasher_function_t *__rehasher;
19012   } _va = {&_fbb, _o, _rehasher};
19013   (void)_va;
19014   return circle::CreateLogicalNotOptions(_fbb);
19015 }
19016
19017 inline UnpackOptionsT *
19018 UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19019 {
19020   auto _o = std::unique_ptr<UnpackOptionsT>(new UnpackOptionsT());
19021   UnPackTo(_o.get(), _resolver);
19022   return _o.release();
19023 }
19024
19025 inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o,
19026                                     const flatbuffers::resolver_function_t *_resolver) const
19027 {
19028   (void)_o;
19029   (void)_resolver;
19030   {
19031     auto _e = num();
19032     _o->num = _e;
19033   }
19034   {
19035     auto _e = axis();
19036     _o->axis = _e;
19037   }
19038 }
19039
19040 inline flatbuffers::Offset<UnpackOptions>
19041 UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o,
19042                     const flatbuffers::rehasher_function_t *_rehasher)
19043 {
19044   return CreateUnpackOptions(_fbb, _o, _rehasher);
19045 }
19046
19047 inline flatbuffers::Offset<UnpackOptions>
19048 CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o,
19049                     const flatbuffers::rehasher_function_t *_rehasher)
19050 {
19051   (void)_rehasher;
19052   (void)_o;
19053   struct _VectorArgs
19054   {
19055     flatbuffers::FlatBufferBuilder *__fbb;
19056     const UnpackOptionsT *__o;
19057     const flatbuffers::rehasher_function_t *__rehasher;
19058   } _va = {&_fbb, _o, _rehasher};
19059   (void)_va;
19060   auto _num = _o->num;
19061   auto _axis = _o->axis;
19062   return circle::CreateUnpackOptions(_fbb, _num, _axis);
19063 }
19064
19065 inline FloorDivOptionsT *
19066 FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19067 {
19068   auto _o = std::unique_ptr<FloorDivOptionsT>(new FloorDivOptionsT());
19069   UnPackTo(_o.get(), _resolver);
19070   return _o.release();
19071 }
19072
19073 inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o,
19074                                       const flatbuffers::resolver_function_t *_resolver) const
19075 {
19076   (void)_o;
19077   (void)_resolver;
19078 }
19079
19080 inline flatbuffers::Offset<FloorDivOptions>
19081 FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o,
19082                       const flatbuffers::rehasher_function_t *_rehasher)
19083 {
19084   return CreateFloorDivOptions(_fbb, _o, _rehasher);
19085 }
19086
19087 inline flatbuffers::Offset<FloorDivOptions>
19088 CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o,
19089                       const flatbuffers::rehasher_function_t *_rehasher)
19090 {
19091   (void)_rehasher;
19092   (void)_o;
19093   struct _VectorArgs
19094   {
19095     flatbuffers::FlatBufferBuilder *__fbb;
19096     const FloorDivOptionsT *__o;
19097     const flatbuffers::rehasher_function_t *__rehasher;
19098   } _va = {&_fbb, _o, _rehasher};
19099   (void)_va;
19100   return circle::CreateFloorDivOptions(_fbb);
19101 }
19102
19103 inline SquareOptionsT *
19104 SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19105 {
19106   auto _o = std::unique_ptr<SquareOptionsT>(new SquareOptionsT());
19107   UnPackTo(_o.get(), _resolver);
19108   return _o.release();
19109 }
19110
19111 inline void SquareOptions::UnPackTo(SquareOptionsT *_o,
19112                                     const flatbuffers::resolver_function_t *_resolver) const
19113 {
19114   (void)_o;
19115   (void)_resolver;
19116 }
19117
19118 inline flatbuffers::Offset<SquareOptions>
19119 SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o,
19120                     const flatbuffers::rehasher_function_t *_rehasher)
19121 {
19122   return CreateSquareOptions(_fbb, _o, _rehasher);
19123 }
19124
19125 inline flatbuffers::Offset<SquareOptions>
19126 CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o,
19127                     const flatbuffers::rehasher_function_t *_rehasher)
19128 {
19129   (void)_rehasher;
19130   (void)_o;
19131   struct _VectorArgs
19132   {
19133     flatbuffers::FlatBufferBuilder *__fbb;
19134     const SquareOptionsT *__o;
19135     const flatbuffers::rehasher_function_t *__rehasher;
19136   } _va = {&_fbb, _o, _rehasher};
19137   (void)_va;
19138   return circle::CreateSquareOptions(_fbb);
19139 }
19140
19141 inline ZerosLikeOptionsT *
19142 ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19143 {
19144   auto _o = std::unique_ptr<ZerosLikeOptionsT>(new ZerosLikeOptionsT());
19145   UnPackTo(_o.get(), _resolver);
19146   return _o.release();
19147 }
19148
19149 inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o,
19150                                        const flatbuffers::resolver_function_t *_resolver) const
19151 {
19152   (void)_o;
19153   (void)_resolver;
19154 }
19155
19156 inline flatbuffers::Offset<ZerosLikeOptions>
19157 ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o,
19158                        const flatbuffers::rehasher_function_t *_rehasher)
19159 {
19160   return CreateZerosLikeOptions(_fbb, _o, _rehasher);
19161 }
19162
19163 inline flatbuffers::Offset<ZerosLikeOptions>
19164 CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o,
19165                        const flatbuffers::rehasher_function_t *_rehasher)
19166 {
19167   (void)_rehasher;
19168   (void)_o;
19169   struct _VectorArgs
19170   {
19171     flatbuffers::FlatBufferBuilder *__fbb;
19172     const ZerosLikeOptionsT *__o;
19173     const flatbuffers::rehasher_function_t *__rehasher;
19174   } _va = {&_fbb, _o, _rehasher};
19175   (void)_va;
19176   return circle::CreateZerosLikeOptions(_fbb);
19177 }
19178
19179 inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19180 {
19181   auto _o = std::unique_ptr<FillOptionsT>(new FillOptionsT());
19182   UnPackTo(_o.get(), _resolver);
19183   return _o.release();
19184 }
19185
19186 inline void FillOptions::UnPackTo(FillOptionsT *_o,
19187                                   const flatbuffers::resolver_function_t *_resolver) const
19188 {
19189   (void)_o;
19190   (void)_resolver;
19191 }
19192
19193 inline flatbuffers::Offset<FillOptions>
19194 FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o,
19195                   const flatbuffers::rehasher_function_t *_rehasher)
19196 {
19197   return CreateFillOptions(_fbb, _o, _rehasher);
19198 }
19199
19200 inline flatbuffers::Offset<FillOptions>
19201 CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o,
19202                   const flatbuffers::rehasher_function_t *_rehasher)
19203 {
19204   (void)_rehasher;
19205   (void)_o;
19206   struct _VectorArgs
19207   {
19208     flatbuffers::FlatBufferBuilder *__fbb;
19209     const FillOptionsT *__o;
19210     const flatbuffers::rehasher_function_t *__rehasher;
19211   } _va = {&_fbb, _o, _rehasher};
19212   (void)_va;
19213   return circle::CreateFillOptions(_fbb);
19214 }
19215
19216 inline FloorModOptionsT *
19217 FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19218 {
19219   auto _o = std::unique_ptr<FloorModOptionsT>(new FloorModOptionsT());
19220   UnPackTo(_o.get(), _resolver);
19221   return _o.release();
19222 }
19223
19224 inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o,
19225                                       const flatbuffers::resolver_function_t *_resolver) const
19226 {
19227   (void)_o;
19228   (void)_resolver;
19229 }
19230
19231 inline flatbuffers::Offset<FloorModOptions>
19232 FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o,
19233                       const flatbuffers::rehasher_function_t *_rehasher)
19234 {
19235   return CreateFloorModOptions(_fbb, _o, _rehasher);
19236 }
19237
19238 inline flatbuffers::Offset<FloorModOptions>
19239 CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o,
19240                       const flatbuffers::rehasher_function_t *_rehasher)
19241 {
19242   (void)_rehasher;
19243   (void)_o;
19244   struct _VectorArgs
19245   {
19246     flatbuffers::FlatBufferBuilder *__fbb;
19247     const FloorModOptionsT *__o;
19248     const flatbuffers::rehasher_function_t *__rehasher;
19249   } _va = {&_fbb, _o, _rehasher};
19250   (void)_va;
19251   return circle::CreateFloorModOptions(_fbb);
19252 }
19253
19254 inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19255 {
19256   auto _o = std::unique_ptr<RangeOptionsT>(new RangeOptionsT());
19257   UnPackTo(_o.get(), _resolver);
19258   return _o.release();
19259 }
19260
19261 inline void RangeOptions::UnPackTo(RangeOptionsT *_o,
19262                                    const flatbuffers::resolver_function_t *_resolver) const
19263 {
19264   (void)_o;
19265   (void)_resolver;
19266 }
19267
19268 inline flatbuffers::Offset<RangeOptions>
19269 RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o,
19270                    const flatbuffers::rehasher_function_t *_rehasher)
19271 {
19272   return CreateRangeOptions(_fbb, _o, _rehasher);
19273 }
19274
19275 inline flatbuffers::Offset<RangeOptions>
19276 CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o,
19277                    const flatbuffers::rehasher_function_t *_rehasher)
19278 {
19279   (void)_rehasher;
19280   (void)_o;
19281   struct _VectorArgs
19282   {
19283     flatbuffers::FlatBufferBuilder *__fbb;
19284     const RangeOptionsT *__o;
19285     const flatbuffers::rehasher_function_t *__rehasher;
19286   } _va = {&_fbb, _o, _rehasher};
19287   (void)_va;
19288   return circle::CreateRangeOptions(_fbb);
19289 }
19290
19291 inline LeakyReluOptionsT *
19292 LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19293 {
19294   auto _o = std::unique_ptr<LeakyReluOptionsT>(new LeakyReluOptionsT());
19295   UnPackTo(_o.get(), _resolver);
19296   return _o.release();
19297 }
19298
19299 inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o,
19300                                        const flatbuffers::resolver_function_t *_resolver) const
19301 {
19302   (void)_o;
19303   (void)_resolver;
19304   {
19305     auto _e = alpha();
19306     _o->alpha = _e;
19307   }
19308 }
19309
19310 inline flatbuffers::Offset<LeakyReluOptions>
19311 LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o,
19312                        const flatbuffers::rehasher_function_t *_rehasher)
19313 {
19314   return CreateLeakyReluOptions(_fbb, _o, _rehasher);
19315 }
19316
19317 inline flatbuffers::Offset<LeakyReluOptions>
19318 CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o,
19319                        const flatbuffers::rehasher_function_t *_rehasher)
19320 {
19321   (void)_rehasher;
19322   (void)_o;
19323   struct _VectorArgs
19324   {
19325     flatbuffers::FlatBufferBuilder *__fbb;
19326     const LeakyReluOptionsT *__o;
19327     const flatbuffers::rehasher_function_t *__rehasher;
19328   } _va = {&_fbb, _o, _rehasher};
19329   (void)_va;
19330   auto _alpha = _o->alpha;
19331   return circle::CreateLeakyReluOptions(_fbb, _alpha);
19332 }
19333
19334 inline SquaredDifferenceOptionsT *
19335 SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19336 {
19337   auto _o = std::unique_ptr<SquaredDifferenceOptionsT>(new SquaredDifferenceOptionsT());
19338   UnPackTo(_o.get(), _resolver);
19339   return _o.release();
19340 }
19341
19342 inline void
19343 SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o,
19344                                    const flatbuffers::resolver_function_t *_resolver) const
19345 {
19346   (void)_o;
19347   (void)_resolver;
19348 }
19349
19350 inline flatbuffers::Offset<SquaredDifferenceOptions>
19351 SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
19352                                const SquaredDifferenceOptionsT *_o,
19353                                const flatbuffers::rehasher_function_t *_rehasher)
19354 {
19355   return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
19356 }
19357
19358 inline flatbuffers::Offset<SquaredDifferenceOptions>
19359 CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb,
19360                                const SquaredDifferenceOptionsT *_o,
19361                                const flatbuffers::rehasher_function_t *_rehasher)
19362 {
19363   (void)_rehasher;
19364   (void)_o;
19365   struct _VectorArgs
19366   {
19367     flatbuffers::FlatBufferBuilder *__fbb;
19368     const SquaredDifferenceOptionsT *__o;
19369     const flatbuffers::rehasher_function_t *__rehasher;
19370   } _va = {&_fbb, _o, _rehasher};
19371   (void)_va;
19372   return circle::CreateSquaredDifferenceOptions(_fbb);
19373 }
19374
19375 inline MirrorPadOptionsT *
19376 MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19377 {
19378   auto _o = std::unique_ptr<MirrorPadOptionsT>(new MirrorPadOptionsT());
19379   UnPackTo(_o.get(), _resolver);
19380   return _o.release();
19381 }
19382
19383 inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o,
19384                                        const flatbuffers::resolver_function_t *_resolver) const
19385 {
19386   (void)_o;
19387   (void)_resolver;
19388   {
19389     auto _e = mode();
19390     _o->mode = _e;
19391   }
19392 }
19393
19394 inline flatbuffers::Offset<MirrorPadOptions>
19395 MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o,
19396                        const flatbuffers::rehasher_function_t *_rehasher)
19397 {
19398   return CreateMirrorPadOptions(_fbb, _o, _rehasher);
19399 }
19400
19401 inline flatbuffers::Offset<MirrorPadOptions>
19402 CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o,
19403                        const flatbuffers::rehasher_function_t *_rehasher)
19404 {
19405   (void)_rehasher;
19406   (void)_o;
19407   struct _VectorArgs
19408   {
19409     flatbuffers::FlatBufferBuilder *__fbb;
19410     const MirrorPadOptionsT *__o;
19411     const flatbuffers::rehasher_function_t *__rehasher;
19412   } _va = {&_fbb, _o, _rehasher};
19413   (void)_va;
19414   auto _mode = _o->mode;
19415   return circle::CreateMirrorPadOptions(_fbb, _mode);
19416 }
19417
19418 inline UniqueOptionsT *
19419 UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19420 {
19421   auto _o = std::unique_ptr<UniqueOptionsT>(new UniqueOptionsT());
19422   UnPackTo(_o.get(), _resolver);
19423   return _o.release();
19424 }
19425
19426 inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o,
19427                                     const flatbuffers::resolver_function_t *_resolver) const
19428 {
19429   (void)_o;
19430   (void)_resolver;
19431   {
19432     auto _e = idx_out_type();
19433     _o->idx_out_type = _e;
19434   }
19435 }
19436
19437 inline flatbuffers::Offset<UniqueOptions>
19438 UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o,
19439                     const flatbuffers::rehasher_function_t *_rehasher)
19440 {
19441   return CreateUniqueOptions(_fbb, _o, _rehasher);
19442 }
19443
19444 inline flatbuffers::Offset<UniqueOptions>
19445 CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o,
19446                     const flatbuffers::rehasher_function_t *_rehasher)
19447 {
19448   (void)_rehasher;
19449   (void)_o;
19450   struct _VectorArgs
19451   {
19452     flatbuffers::FlatBufferBuilder *__fbb;
19453     const UniqueOptionsT *__o;
19454     const flatbuffers::rehasher_function_t *__rehasher;
19455   } _va = {&_fbb, _o, _rehasher};
19456   (void)_va;
19457   auto _idx_out_type = _o->idx_out_type;
19458   return circle::CreateUniqueOptions(_fbb, _idx_out_type);
19459 }
19460
19461 inline ReverseV2OptionsT *
19462 ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19463 {
19464   auto _o = std::unique_ptr<ReverseV2OptionsT>(new ReverseV2OptionsT());
19465   UnPackTo(_o.get(), _resolver);
19466   return _o.release();
19467 }
19468
19469 inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o,
19470                                        const flatbuffers::resolver_function_t *_resolver) const
19471 {
19472   (void)_o;
19473   (void)_resolver;
19474 }
19475
19476 inline flatbuffers::Offset<ReverseV2Options>
19477 ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o,
19478                        const flatbuffers::rehasher_function_t *_rehasher)
19479 {
19480   return CreateReverseV2Options(_fbb, _o, _rehasher);
19481 }
19482
19483 inline flatbuffers::Offset<ReverseV2Options>
19484 CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o,
19485                        const flatbuffers::rehasher_function_t *_rehasher)
19486 {
19487   (void)_rehasher;
19488   (void)_o;
19489   struct _VectorArgs
19490   {
19491     flatbuffers::FlatBufferBuilder *__fbb;
19492     const ReverseV2OptionsT *__o;
19493     const flatbuffers::rehasher_function_t *__rehasher;
19494   } _va = {&_fbb, _o, _rehasher};
19495   (void)_va;
19496   return circle::CreateReverseV2Options(_fbb);
19497 }
19498
19499 inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19500 {
19501   auto _o = std::unique_ptr<AddNOptionsT>(new AddNOptionsT());
19502   UnPackTo(_o.get(), _resolver);
19503   return _o.release();
19504 }
19505
19506 inline void AddNOptions::UnPackTo(AddNOptionsT *_o,
19507                                   const flatbuffers::resolver_function_t *_resolver) const
19508 {
19509   (void)_o;
19510   (void)_resolver;
19511 }
19512
19513 inline flatbuffers::Offset<AddNOptions>
19514 AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o,
19515                   const flatbuffers::rehasher_function_t *_rehasher)
19516 {
19517   return CreateAddNOptions(_fbb, _o, _rehasher);
19518 }
19519
19520 inline flatbuffers::Offset<AddNOptions>
19521 CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o,
19522                   const flatbuffers::rehasher_function_t *_rehasher)
19523 {
19524   (void)_rehasher;
19525   (void)_o;
19526   struct _VectorArgs
19527   {
19528     flatbuffers::FlatBufferBuilder *__fbb;
19529     const AddNOptionsT *__o;
19530     const flatbuffers::rehasher_function_t *__rehasher;
19531   } _va = {&_fbb, _o, _rehasher};
19532   (void)_va;
19533   return circle::CreateAddNOptions(_fbb);
19534 }
19535
19536 inline GatherNdOptionsT *
19537 GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19538 {
19539   auto _o = std::unique_ptr<GatherNdOptionsT>(new GatherNdOptionsT());
19540   UnPackTo(_o.get(), _resolver);
19541   return _o.release();
19542 }
19543
19544 inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o,
19545                                       const flatbuffers::resolver_function_t *_resolver) const
19546 {
19547   (void)_o;
19548   (void)_resolver;
19549 }
19550
19551 inline flatbuffers::Offset<GatherNdOptions>
19552 GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o,
19553                       const flatbuffers::rehasher_function_t *_rehasher)
19554 {
19555   return CreateGatherNdOptions(_fbb, _o, _rehasher);
19556 }
19557
19558 inline flatbuffers::Offset<GatherNdOptions>
19559 CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o,
19560                       const flatbuffers::rehasher_function_t *_rehasher)
19561 {
19562   (void)_rehasher;
19563   (void)_o;
19564   struct _VectorArgs
19565   {
19566     flatbuffers::FlatBufferBuilder *__fbb;
19567     const GatherNdOptionsT *__o;
19568     const flatbuffers::rehasher_function_t *__rehasher;
19569   } _va = {&_fbb, _o, _rehasher};
19570   (void)_va;
19571   return circle::CreateGatherNdOptions(_fbb);
19572 }
19573
19574 inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19575 {
19576   auto _o = std::unique_ptr<WhereOptionsT>(new WhereOptionsT());
19577   UnPackTo(_o.get(), _resolver);
19578   return _o.release();
19579 }
19580
19581 inline void WhereOptions::UnPackTo(WhereOptionsT *_o,
19582                                    const flatbuffers::resolver_function_t *_resolver) const
19583 {
19584   (void)_o;
19585   (void)_resolver;
19586 }
19587
19588 inline flatbuffers::Offset<WhereOptions>
19589 WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o,
19590                    const flatbuffers::rehasher_function_t *_rehasher)
19591 {
19592   return CreateWhereOptions(_fbb, _o, _rehasher);
19593 }
19594
19595 inline flatbuffers::Offset<WhereOptions>
19596 CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o,
19597                    const flatbuffers::rehasher_function_t *_rehasher)
19598 {
19599   (void)_rehasher;
19600   (void)_o;
19601   struct _VectorArgs
19602   {
19603     flatbuffers::FlatBufferBuilder *__fbb;
19604     const WhereOptionsT *__o;
19605     const flatbuffers::rehasher_function_t *__rehasher;
19606   } _va = {&_fbb, _o, _rehasher};
19607   (void)_va;
19608   return circle::CreateWhereOptions(_fbb);
19609 }
19610
19611 inline ReverseSequenceOptionsT *
19612 ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19613 {
19614   auto _o = std::unique_ptr<ReverseSequenceOptionsT>(new ReverseSequenceOptionsT());
19615   UnPackTo(_o.get(), _resolver);
19616   return _o.release();
19617 }
19618
19619 inline void
19620 ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o,
19621                                  const flatbuffers::resolver_function_t *_resolver) const
19622 {
19623   (void)_o;
19624   (void)_resolver;
19625   {
19626     auto _e = seq_dim();
19627     _o->seq_dim = _e;
19628   }
19629   {
19630     auto _e = batch_dim();
19631     _o->batch_dim = _e;
19632   }
19633 }
19634
19635 inline flatbuffers::Offset<ReverseSequenceOptions>
19636 ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
19637                              const ReverseSequenceOptionsT *_o,
19638                              const flatbuffers::rehasher_function_t *_rehasher)
19639 {
19640   return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
19641 }
19642
19643 inline flatbuffers::Offset<ReverseSequenceOptions>
19644 CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb,
19645                              const ReverseSequenceOptionsT *_o,
19646                              const flatbuffers::rehasher_function_t *_rehasher)
19647 {
19648   (void)_rehasher;
19649   (void)_o;
19650   struct _VectorArgs
19651   {
19652     flatbuffers::FlatBufferBuilder *__fbb;
19653     const ReverseSequenceOptionsT *__o;
19654     const flatbuffers::rehasher_function_t *__rehasher;
19655   } _va = {&_fbb, _o, _rehasher};
19656   (void)_va;
19657   auto _seq_dim = _o->seq_dim;
19658   auto _batch_dim = _o->batch_dim;
19659   return circle::CreateReverseSequenceOptions(_fbb, _seq_dim, _batch_dim);
19660 }
19661
19662 inline MatrixDiagOptionsT *
19663 MatrixDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19664 {
19665   auto _o = std::unique_ptr<MatrixDiagOptionsT>(new MatrixDiagOptionsT());
19666   UnPackTo(_o.get(), _resolver);
19667   return _o.release();
19668 }
19669
19670 inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o,
19671                                         const flatbuffers::resolver_function_t *_resolver) const
19672 {
19673   (void)_o;
19674   (void)_resolver;
19675 }
19676
19677 inline flatbuffers::Offset<MatrixDiagOptions>
19678 MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o,
19679                         const flatbuffers::rehasher_function_t *_rehasher)
19680 {
19681   return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
19682 }
19683
19684 inline flatbuffers::Offset<MatrixDiagOptions>
19685 CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o,
19686                         const flatbuffers::rehasher_function_t *_rehasher)
19687 {
19688   (void)_rehasher;
19689   (void)_o;
19690   struct _VectorArgs
19691   {
19692     flatbuffers::FlatBufferBuilder *__fbb;
19693     const MatrixDiagOptionsT *__o;
19694     const flatbuffers::rehasher_function_t *__rehasher;
19695   } _va = {&_fbb, _o, _rehasher};
19696   (void)_va;
19697   return circle::CreateMatrixDiagOptions(_fbb);
19698 }
19699
19700 inline QuantizeOptionsT *
19701 QuantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19702 {
19703   auto _o = std::unique_ptr<QuantizeOptionsT>(new QuantizeOptionsT());
19704   UnPackTo(_o.get(), _resolver);
19705   return _o.release();
19706 }
19707
19708 inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o,
19709                                       const flatbuffers::resolver_function_t *_resolver) const
19710 {
19711   (void)_o;
19712   (void)_resolver;
19713 }
19714
19715 inline flatbuffers::Offset<QuantizeOptions>
19716 QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o,
19717                       const flatbuffers::rehasher_function_t *_rehasher)
19718 {
19719   return CreateQuantizeOptions(_fbb, _o, _rehasher);
19720 }
19721
19722 inline flatbuffers::Offset<QuantizeOptions>
19723 CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o,
19724                       const flatbuffers::rehasher_function_t *_rehasher)
19725 {
19726   (void)_rehasher;
19727   (void)_o;
19728   struct _VectorArgs
19729   {
19730     flatbuffers::FlatBufferBuilder *__fbb;
19731     const QuantizeOptionsT *__o;
19732     const flatbuffers::rehasher_function_t *__rehasher;
19733   } _va = {&_fbb, _o, _rehasher};
19734   (void)_va;
19735   return circle::CreateQuantizeOptions(_fbb);
19736 }
19737
19738 inline MatrixSetDiagOptionsT *
19739 MatrixSetDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19740 {
19741   auto _o = std::unique_ptr<MatrixSetDiagOptionsT>(new MatrixSetDiagOptionsT());
19742   UnPackTo(_o.get(), _resolver);
19743   return _o.release();
19744 }
19745
19746 inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o,
19747                                            const flatbuffers::resolver_function_t *_resolver) const
19748 {
19749   (void)_o;
19750   (void)_resolver;
19751 }
19752
19753 inline flatbuffers::Offset<MatrixSetDiagOptions>
19754 MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o,
19755                            const flatbuffers::rehasher_function_t *_rehasher)
19756 {
19757   return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
19758 }
19759
19760 inline flatbuffers::Offset<MatrixSetDiagOptions>
19761 CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o,
19762                            const flatbuffers::rehasher_function_t *_rehasher)
19763 {
19764   (void)_rehasher;
19765   (void)_o;
19766   struct _VectorArgs
19767   {
19768     flatbuffers::FlatBufferBuilder *__fbb;
19769     const MatrixSetDiagOptionsT *__o;
19770     const flatbuffers::rehasher_function_t *__rehasher;
19771   } _va = {&_fbb, _o, _rehasher};
19772   (void)_va;
19773   return circle::CreateMatrixSetDiagOptions(_fbb);
19774 }
19775
19776 inline IfOptionsT *IfOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19777 {
19778   auto _o = std::unique_ptr<IfOptionsT>(new IfOptionsT());
19779   UnPackTo(_o.get(), _resolver);
19780   return _o.release();
19781 }
19782
19783 inline void IfOptions::UnPackTo(IfOptionsT *_o,
19784                                 const flatbuffers::resolver_function_t *_resolver) const
19785 {
19786   (void)_o;
19787   (void)_resolver;
19788   {
19789     auto _e = then_subgraph_index();
19790     _o->then_subgraph_index = _e;
19791   }
19792   {
19793     auto _e = else_subgraph_index();
19794     _o->else_subgraph_index = _e;
19795   }
19796 }
19797
19798 inline flatbuffers::Offset<IfOptions>
19799 IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o,
19800                 const flatbuffers::rehasher_function_t *_rehasher)
19801 {
19802   return CreateIfOptions(_fbb, _o, _rehasher);
19803 }
19804
19805 inline flatbuffers::Offset<IfOptions>
19806 CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o,
19807                 const flatbuffers::rehasher_function_t *_rehasher)
19808 {
19809   (void)_rehasher;
19810   (void)_o;
19811   struct _VectorArgs
19812   {
19813     flatbuffers::FlatBufferBuilder *__fbb;
19814     const IfOptionsT *__o;
19815     const flatbuffers::rehasher_function_t *__rehasher;
19816   } _va = {&_fbb, _o, _rehasher};
19817   (void)_va;
19818   auto _then_subgraph_index = _o->then_subgraph_index;
19819   auto _else_subgraph_index = _o->else_subgraph_index;
19820   return circle::CreateIfOptions(_fbb, _then_subgraph_index, _else_subgraph_index);
19821 }
19822
19823 inline CallOnceOptionsT *
19824 CallOnceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19825 {
19826   auto _o = std::unique_ptr<CallOnceOptionsT>(new CallOnceOptionsT());
19827   UnPackTo(_o.get(), _resolver);
19828   return _o.release();
19829 }
19830
19831 inline void CallOnceOptions::UnPackTo(CallOnceOptionsT *_o,
19832                                       const flatbuffers::resolver_function_t *_resolver) const
19833 {
19834   (void)_o;
19835   (void)_resolver;
19836   {
19837     auto _e = init_subgraph_index();
19838     _o->init_subgraph_index = _e;
19839   }
19840 }
19841
19842 inline flatbuffers::Offset<CallOnceOptions>
19843 CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o,
19844                       const flatbuffers::rehasher_function_t *_rehasher)
19845 {
19846   return CreateCallOnceOptions(_fbb, _o, _rehasher);
19847 }
19848
19849 inline flatbuffers::Offset<CallOnceOptions>
19850 CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o,
19851                       const flatbuffers::rehasher_function_t *_rehasher)
19852 {
19853   (void)_rehasher;
19854   (void)_o;
19855   struct _VectorArgs
19856   {
19857     flatbuffers::FlatBufferBuilder *__fbb;
19858     const CallOnceOptionsT *__o;
19859     const flatbuffers::rehasher_function_t *__rehasher;
19860   } _va = {&_fbb, _o, _rehasher};
19861   (void)_va;
19862   auto _init_subgraph_index = _o->init_subgraph_index;
19863   return circle::CreateCallOnceOptions(_fbb, _init_subgraph_index);
19864 }
19865
19866 inline WhileOptionsT *WhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19867 {
19868   auto _o = std::unique_ptr<WhileOptionsT>(new WhileOptionsT());
19869   UnPackTo(_o.get(), _resolver);
19870   return _o.release();
19871 }
19872
19873 inline void WhileOptions::UnPackTo(WhileOptionsT *_o,
19874                                    const flatbuffers::resolver_function_t *_resolver) const
19875 {
19876   (void)_o;
19877   (void)_resolver;
19878   {
19879     auto _e = cond_subgraph_index();
19880     _o->cond_subgraph_index = _e;
19881   }
19882   {
19883     auto _e = body_subgraph_index();
19884     _o->body_subgraph_index = _e;
19885   }
19886 }
19887
19888 inline flatbuffers::Offset<WhileOptions>
19889 WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o,
19890                    const flatbuffers::rehasher_function_t *_rehasher)
19891 {
19892   return CreateWhileOptions(_fbb, _o, _rehasher);
19893 }
19894
19895 inline flatbuffers::Offset<WhileOptions>
19896 CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o,
19897                    const flatbuffers::rehasher_function_t *_rehasher)
19898 {
19899   (void)_rehasher;
19900   (void)_o;
19901   struct _VectorArgs
19902   {
19903     flatbuffers::FlatBufferBuilder *__fbb;
19904     const WhileOptionsT *__o;
19905     const flatbuffers::rehasher_function_t *__rehasher;
19906   } _va = {&_fbb, _o, _rehasher};
19907   (void)_va;
19908   auto _cond_subgraph_index = _o->cond_subgraph_index;
19909   auto _body_subgraph_index = _o->body_subgraph_index;
19910   return circle::CreateWhileOptions(_fbb, _cond_subgraph_index, _body_subgraph_index);
19911 }
19912
19913 inline NonMaxSuppressionV4OptionsT *
19914 NonMaxSuppressionV4Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19915 {
19916   auto _o = std::unique_ptr<NonMaxSuppressionV4OptionsT>(new NonMaxSuppressionV4OptionsT());
19917   UnPackTo(_o.get(), _resolver);
19918   return _o.release();
19919 }
19920
19921 inline void
19922 NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o,
19923                                      const flatbuffers::resolver_function_t *_resolver) const
19924 {
19925   (void)_o;
19926   (void)_resolver;
19927 }
19928
19929 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
19930 NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb,
19931                                  const NonMaxSuppressionV4OptionsT *_o,
19932                                  const flatbuffers::rehasher_function_t *_rehasher)
19933 {
19934   return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
19935 }
19936
19937 inline flatbuffers::Offset<NonMaxSuppressionV4Options>
19938 CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb,
19939                                  const NonMaxSuppressionV4OptionsT *_o,
19940                                  const flatbuffers::rehasher_function_t *_rehasher)
19941 {
19942   (void)_rehasher;
19943   (void)_o;
19944   struct _VectorArgs
19945   {
19946     flatbuffers::FlatBufferBuilder *__fbb;
19947     const NonMaxSuppressionV4OptionsT *__o;
19948     const flatbuffers::rehasher_function_t *__rehasher;
19949   } _va = {&_fbb, _o, _rehasher};
19950   (void)_va;
19951   return circle::CreateNonMaxSuppressionV4Options(_fbb);
19952 }
19953
19954 inline NonMaxSuppressionV5OptionsT *
19955 NonMaxSuppressionV5Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19956 {
19957   auto _o = std::unique_ptr<NonMaxSuppressionV5OptionsT>(new NonMaxSuppressionV5OptionsT());
19958   UnPackTo(_o.get(), _resolver);
19959   return _o.release();
19960 }
19961
19962 inline void
19963 NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o,
19964                                      const flatbuffers::resolver_function_t *_resolver) const
19965 {
19966   (void)_o;
19967   (void)_resolver;
19968 }
19969
19970 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
19971 NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb,
19972                                  const NonMaxSuppressionV5OptionsT *_o,
19973                                  const flatbuffers::rehasher_function_t *_rehasher)
19974 {
19975   return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
19976 }
19977
19978 inline flatbuffers::Offset<NonMaxSuppressionV5Options>
19979 CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb,
19980                                  const NonMaxSuppressionV5OptionsT *_o,
19981                                  const flatbuffers::rehasher_function_t *_rehasher)
19982 {
19983   (void)_rehasher;
19984   (void)_o;
19985   struct _VectorArgs
19986   {
19987     flatbuffers::FlatBufferBuilder *__fbb;
19988     const NonMaxSuppressionV5OptionsT *__o;
19989     const flatbuffers::rehasher_function_t *__rehasher;
19990   } _va = {&_fbb, _o, _rehasher};
19991   (void)_va;
19992   return circle::CreateNonMaxSuppressionV5Options(_fbb);
19993 }
19994
19995 inline ScatterNdOptionsT *
19996 ScatterNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
19997 {
19998   auto _o = std::unique_ptr<ScatterNdOptionsT>(new ScatterNdOptionsT());
19999   UnPackTo(_o.get(), _resolver);
20000   return _o.release();
20001 }
20002
20003 inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o,
20004                                        const flatbuffers::resolver_function_t *_resolver) const
20005 {
20006   (void)_o;
20007   (void)_resolver;
20008 }
20009
20010 inline flatbuffers::Offset<ScatterNdOptions>
20011 ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o,
20012                        const flatbuffers::rehasher_function_t *_rehasher)
20013 {
20014   return CreateScatterNdOptions(_fbb, _o, _rehasher);
20015 }
20016
20017 inline flatbuffers::Offset<ScatterNdOptions>
20018 CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o,
20019                        const flatbuffers::rehasher_function_t *_rehasher)
20020 {
20021   (void)_rehasher;
20022   (void)_o;
20023   struct _VectorArgs
20024   {
20025     flatbuffers::FlatBufferBuilder *__fbb;
20026     const ScatterNdOptionsT *__o;
20027     const flatbuffers::rehasher_function_t *__rehasher;
20028   } _va = {&_fbb, _o, _rehasher};
20029   (void)_va;
20030   return circle::CreateScatterNdOptions(_fbb);
20031 }
20032
20033 inline SelectV2OptionsT *
20034 SelectV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20035 {
20036   auto _o = std::unique_ptr<SelectV2OptionsT>(new SelectV2OptionsT());
20037   UnPackTo(_o.get(), _resolver);
20038   return _o.release();
20039 }
20040
20041 inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o,
20042                                       const flatbuffers::resolver_function_t *_resolver) const
20043 {
20044   (void)_o;
20045   (void)_resolver;
20046 }
20047
20048 inline flatbuffers::Offset<SelectV2Options>
20049 SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o,
20050                       const flatbuffers::rehasher_function_t *_rehasher)
20051 {
20052   return CreateSelectV2Options(_fbb, _o, _rehasher);
20053 }
20054
20055 inline flatbuffers::Offset<SelectV2Options>
20056 CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o,
20057                       const flatbuffers::rehasher_function_t *_rehasher)
20058 {
20059   (void)_rehasher;
20060   (void)_o;
20061   struct _VectorArgs
20062   {
20063     flatbuffers::FlatBufferBuilder *__fbb;
20064     const SelectV2OptionsT *__o;
20065     const flatbuffers::rehasher_function_t *__rehasher;
20066   } _va = {&_fbb, _o, _rehasher};
20067   (void)_va;
20068   return circle::CreateSelectV2Options(_fbb);
20069 }
20070
20071 inline DensifyOptionsT *
20072 DensifyOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20073 {
20074   auto _o = std::unique_ptr<DensifyOptionsT>(new DensifyOptionsT());
20075   UnPackTo(_o.get(), _resolver);
20076   return _o.release();
20077 }
20078
20079 inline void DensifyOptions::UnPackTo(DensifyOptionsT *_o,
20080                                      const flatbuffers::resolver_function_t *_resolver) const
20081 {
20082   (void)_o;
20083   (void)_resolver;
20084 }
20085
20086 inline flatbuffers::Offset<DensifyOptions>
20087 DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o,
20088                      const flatbuffers::rehasher_function_t *_rehasher)
20089 {
20090   return CreateDensifyOptions(_fbb, _o, _rehasher);
20091 }
20092
20093 inline flatbuffers::Offset<DensifyOptions>
20094 CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o,
20095                      const flatbuffers::rehasher_function_t *_rehasher)
20096 {
20097   (void)_rehasher;
20098   (void)_o;
20099   struct _VectorArgs
20100   {
20101     flatbuffers::FlatBufferBuilder *__fbb;
20102     const DensifyOptionsT *__o;
20103     const flatbuffers::rehasher_function_t *__rehasher;
20104   } _va = {&_fbb, _o, _rehasher};
20105   (void)_va;
20106   return circle::CreateDensifyOptions(_fbb);
20107 }
20108
20109 inline SegmentSumOptionsT *
20110 SegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20111 {
20112   auto _o = std::unique_ptr<SegmentSumOptionsT>(new SegmentSumOptionsT());
20113   UnPackTo(_o.get(), _resolver);
20114   return _o.release();
20115 }
20116
20117 inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT *_o,
20118                                         const flatbuffers::resolver_function_t *_resolver) const
20119 {
20120   (void)_o;
20121   (void)_resolver;
20122 }
20123
20124 inline flatbuffers::Offset<SegmentSumOptions>
20125 SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o,
20126                         const flatbuffers::rehasher_function_t *_rehasher)
20127 {
20128   return CreateSegmentSumOptions(_fbb, _o, _rehasher);
20129 }
20130
20131 inline flatbuffers::Offset<SegmentSumOptions>
20132 CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o,
20133                         const flatbuffers::rehasher_function_t *_rehasher)
20134 {
20135   (void)_rehasher;
20136   (void)_o;
20137   struct _VectorArgs
20138   {
20139     flatbuffers::FlatBufferBuilder *__fbb;
20140     const SegmentSumOptionsT *__o;
20141     const flatbuffers::rehasher_function_t *__rehasher;
20142   } _va = {&_fbb, _o, _rehasher};
20143   (void)_va;
20144   return circle::CreateSegmentSumOptions(_fbb);
20145 }
20146
20147 inline BatchMatMulOptionsT *
20148 BatchMatMulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20149 {
20150   auto _o = std::unique_ptr<BatchMatMulOptionsT>(new BatchMatMulOptionsT());
20151   UnPackTo(_o.get(), _resolver);
20152   return _o.release();
20153 }
20154
20155 inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o,
20156                                          const flatbuffers::resolver_function_t *_resolver) const
20157 {
20158   (void)_o;
20159   (void)_resolver;
20160   {
20161     auto _e = adjoint_lhs();
20162     _o->adjoint_lhs = _e;
20163   }
20164   {
20165     auto _e = adjoint_rhs();
20166     _o->adjoint_rhs = _e;
20167   }
20168   {
20169     auto _e = asymmetric_quantize_inputs();
20170     _o->asymmetric_quantize_inputs = _e;
20171   }
20172 }
20173
20174 inline flatbuffers::Offset<BatchMatMulOptions>
20175 BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o,
20176                          const flatbuffers::rehasher_function_t *_rehasher)
20177 {
20178   return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
20179 }
20180
20181 inline flatbuffers::Offset<BatchMatMulOptions>
20182 CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o,
20183                          const flatbuffers::rehasher_function_t *_rehasher)
20184 {
20185   (void)_rehasher;
20186   (void)_o;
20187   struct _VectorArgs
20188   {
20189     flatbuffers::FlatBufferBuilder *__fbb;
20190     const BatchMatMulOptionsT *__o;
20191     const flatbuffers::rehasher_function_t *__rehasher;
20192   } _va = {&_fbb, _o, _rehasher};
20193   (void)_va;
20194   auto _adjoint_lhs = _o->adjoint_lhs;
20195   auto _adjoint_rhs = _o->adjoint_rhs;
20196   auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
20197   return circle::CreateBatchMatMulOptions(_fbb, _adjoint_lhs, _adjoint_rhs,
20198                                           _asymmetric_quantize_inputs);
20199 }
20200
20201 inline CumsumOptionsT *
20202 CumsumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20203 {
20204   auto _o = std::unique_ptr<CumsumOptionsT>(new CumsumOptionsT());
20205   UnPackTo(_o.get(), _resolver);
20206   return _o.release();
20207 }
20208
20209 inline void CumsumOptions::UnPackTo(CumsumOptionsT *_o,
20210                                     const flatbuffers::resolver_function_t *_resolver) const
20211 {
20212   (void)_o;
20213   (void)_resolver;
20214   {
20215     auto _e = exclusive();
20216     _o->exclusive = _e;
20217   }
20218   {
20219     auto _e = reverse();
20220     _o->reverse = _e;
20221   }
20222 }
20223
20224 inline flatbuffers::Offset<CumsumOptions>
20225 CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o,
20226                     const flatbuffers::rehasher_function_t *_rehasher)
20227 {
20228   return CreateCumsumOptions(_fbb, _o, _rehasher);
20229 }
20230
20231 inline flatbuffers::Offset<CumsumOptions>
20232 CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o,
20233                     const flatbuffers::rehasher_function_t *_rehasher)
20234 {
20235   (void)_rehasher;
20236   (void)_o;
20237   struct _VectorArgs
20238   {
20239     flatbuffers::FlatBufferBuilder *__fbb;
20240     const CumsumOptionsT *__o;
20241     const flatbuffers::rehasher_function_t *__rehasher;
20242   } _va = {&_fbb, _o, _rehasher};
20243   (void)_va;
20244   auto _exclusive = _o->exclusive;
20245   auto _reverse = _o->reverse;
20246   return circle::CreateCumsumOptions(_fbb, _exclusive, _reverse);
20247 }
20248
20249 inline BroadcastToOptionsT *
20250 BroadcastToOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20251 {
20252   auto _o = std::unique_ptr<BroadcastToOptionsT>(new BroadcastToOptionsT());
20253   UnPackTo(_o.get(), _resolver);
20254   return _o.release();
20255 }
20256
20257 inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT *_o,
20258                                          const flatbuffers::resolver_function_t *_resolver) const
20259 {
20260   (void)_o;
20261   (void)_resolver;
20262 }
20263
20264 inline flatbuffers::Offset<BroadcastToOptions>
20265 BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o,
20266                          const flatbuffers::rehasher_function_t *_rehasher)
20267 {
20268   return CreateBroadcastToOptions(_fbb, _o, _rehasher);
20269 }
20270
20271 inline flatbuffers::Offset<BroadcastToOptions>
20272 CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o,
20273                          const flatbuffers::rehasher_function_t *_rehasher)
20274 {
20275   (void)_rehasher;
20276   (void)_o;
20277   struct _VectorArgs
20278   {
20279     flatbuffers::FlatBufferBuilder *__fbb;
20280     const BroadcastToOptionsT *__o;
20281     const flatbuffers::rehasher_function_t *__rehasher;
20282   } _va = {&_fbb, _o, _rehasher};
20283   (void)_va;
20284   return circle::CreateBroadcastToOptions(_fbb);
20285 }
20286
20287 inline Rfft2dOptionsT *
20288 Rfft2dOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20289 {
20290   auto _o = std::unique_ptr<Rfft2dOptionsT>(new Rfft2dOptionsT());
20291   UnPackTo(_o.get(), _resolver);
20292   return _o.release();
20293 }
20294
20295 inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT *_o,
20296                                     const flatbuffers::resolver_function_t *_resolver) const
20297 {
20298   (void)_o;
20299   (void)_resolver;
20300 }
20301
20302 inline flatbuffers::Offset<Rfft2dOptions>
20303 Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o,
20304                     const flatbuffers::rehasher_function_t *_rehasher)
20305 {
20306   return CreateRfft2dOptions(_fbb, _o, _rehasher);
20307 }
20308
20309 inline flatbuffers::Offset<Rfft2dOptions>
20310 CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o,
20311                     const flatbuffers::rehasher_function_t *_rehasher)
20312 {
20313   (void)_rehasher;
20314   (void)_o;
20315   struct _VectorArgs
20316   {
20317     flatbuffers::FlatBufferBuilder *__fbb;
20318     const Rfft2dOptionsT *__o;
20319     const flatbuffers::rehasher_function_t *__rehasher;
20320   } _va = {&_fbb, _o, _rehasher};
20321   (void)_va;
20322   return circle::CreateRfft2dOptions(_fbb);
20323 }
20324
20325 inline HashtableOptionsT *
20326 HashtableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20327 {
20328   auto _o = std::unique_ptr<HashtableOptionsT>(new HashtableOptionsT());
20329   UnPackTo(_o.get(), _resolver);
20330   return _o.release();
20331 }
20332
20333 inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o,
20334                                        const flatbuffers::resolver_function_t *_resolver) const
20335 {
20336   (void)_o;
20337   (void)_resolver;
20338   {
20339     auto _e = table_id();
20340     _o->table_id = _e;
20341   }
20342   {
20343     auto _e = key_dtype();
20344     _o->key_dtype = _e;
20345   }
20346   {
20347     auto _e = value_dtype();
20348     _o->value_dtype = _e;
20349   }
20350 }
20351
20352 inline flatbuffers::Offset<HashtableOptions>
20353 HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o,
20354                        const flatbuffers::rehasher_function_t *_rehasher)
20355 {
20356   return CreateHashtableOptions(_fbb, _o, _rehasher);
20357 }
20358
20359 inline flatbuffers::Offset<HashtableOptions>
20360 CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o,
20361                        const flatbuffers::rehasher_function_t *_rehasher)
20362 {
20363   (void)_rehasher;
20364   (void)_o;
20365   struct _VectorArgs
20366   {
20367     flatbuffers::FlatBufferBuilder *__fbb;
20368     const HashtableOptionsT *__o;
20369     const flatbuffers::rehasher_function_t *__rehasher;
20370   } _va = {&_fbb, _o, _rehasher};
20371   (void)_va;
20372   auto _table_id = _o->table_id;
20373   auto _key_dtype = _o->key_dtype;
20374   auto _value_dtype = _o->value_dtype;
20375   return circle::CreateHashtableOptions(_fbb, _table_id, _key_dtype, _value_dtype);
20376 }
20377
20378 inline HashtableFindOptionsT *
20379 HashtableFindOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20380 {
20381   auto _o = std::unique_ptr<HashtableFindOptionsT>(new HashtableFindOptionsT());
20382   UnPackTo(_o.get(), _resolver);
20383   return _o.release();
20384 }
20385
20386 inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT *_o,
20387                                            const flatbuffers::resolver_function_t *_resolver) const
20388 {
20389   (void)_o;
20390   (void)_resolver;
20391 }
20392
20393 inline flatbuffers::Offset<HashtableFindOptions>
20394 HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o,
20395                            const flatbuffers::rehasher_function_t *_rehasher)
20396 {
20397   return CreateHashtableFindOptions(_fbb, _o, _rehasher);
20398 }
20399
20400 inline flatbuffers::Offset<HashtableFindOptions>
20401 CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o,
20402                            const flatbuffers::rehasher_function_t *_rehasher)
20403 {
20404   (void)_rehasher;
20405   (void)_o;
20406   struct _VectorArgs
20407   {
20408     flatbuffers::FlatBufferBuilder *__fbb;
20409     const HashtableFindOptionsT *__o;
20410     const flatbuffers::rehasher_function_t *__rehasher;
20411   } _va = {&_fbb, _o, _rehasher};
20412   (void)_va;
20413   return circle::CreateHashtableFindOptions(_fbb);
20414 }
20415
20416 inline HashtableImportOptionsT *
20417 HashtableImportOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20418 {
20419   auto _o = std::unique_ptr<HashtableImportOptionsT>(new HashtableImportOptionsT());
20420   UnPackTo(_o.get(), _resolver);
20421   return _o.release();
20422 }
20423
20424 inline void
20425 HashtableImportOptions::UnPackTo(HashtableImportOptionsT *_o,
20426                                  const flatbuffers::resolver_function_t *_resolver) const
20427 {
20428   (void)_o;
20429   (void)_resolver;
20430 }
20431
20432 inline flatbuffers::Offset<HashtableImportOptions>
20433 HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
20434                              const HashtableImportOptionsT *_o,
20435                              const flatbuffers::rehasher_function_t *_rehasher)
20436 {
20437   return CreateHashtableImportOptions(_fbb, _o, _rehasher);
20438 }
20439
20440 inline flatbuffers::Offset<HashtableImportOptions>
20441 CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb,
20442                              const HashtableImportOptionsT *_o,
20443                              const flatbuffers::rehasher_function_t *_rehasher)
20444 {
20445   (void)_rehasher;
20446   (void)_o;
20447   struct _VectorArgs
20448   {
20449     flatbuffers::FlatBufferBuilder *__fbb;
20450     const HashtableImportOptionsT *__o;
20451     const flatbuffers::rehasher_function_t *__rehasher;
20452   } _va = {&_fbb, _o, _rehasher};
20453   (void)_va;
20454   return circle::CreateHashtableImportOptions(_fbb);
20455 }
20456
20457 inline HashtableSizeOptionsT *
20458 HashtableSizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20459 {
20460   auto _o = std::unique_ptr<HashtableSizeOptionsT>(new HashtableSizeOptionsT());
20461   UnPackTo(_o.get(), _resolver);
20462   return _o.release();
20463 }
20464
20465 inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT *_o,
20466                                            const flatbuffers::resolver_function_t *_resolver) const
20467 {
20468   (void)_o;
20469   (void)_resolver;
20470 }
20471
20472 inline flatbuffers::Offset<HashtableSizeOptions>
20473 HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o,
20474                            const flatbuffers::rehasher_function_t *_rehasher)
20475 {
20476   return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
20477 }
20478
20479 inline flatbuffers::Offset<HashtableSizeOptions>
20480 CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o,
20481                            const flatbuffers::rehasher_function_t *_rehasher)
20482 {
20483   (void)_rehasher;
20484   (void)_o;
20485   struct _VectorArgs
20486   {
20487     flatbuffers::FlatBufferBuilder *__fbb;
20488     const HashtableSizeOptionsT *__o;
20489     const flatbuffers::rehasher_function_t *__rehasher;
20490   } _va = {&_fbb, _o, _rehasher};
20491   (void)_va;
20492   return circle::CreateHashtableSizeOptions(_fbb);
20493 }
20494
20495 inline VarHandleOptionsT *
20496 VarHandleOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20497 {
20498   auto _o = std::unique_ptr<VarHandleOptionsT>(new VarHandleOptionsT());
20499   UnPackTo(_o.get(), _resolver);
20500   return _o.release();
20501 }
20502
20503 inline void VarHandleOptions::UnPackTo(VarHandleOptionsT *_o,
20504                                        const flatbuffers::resolver_function_t *_resolver) const
20505 {
20506   (void)_o;
20507   (void)_resolver;
20508   {
20509     auto _e = container();
20510     if (_e)
20511       _o->container = _e->str();
20512   }
20513   {
20514     auto _e = shared_name();
20515     if (_e)
20516       _o->shared_name = _e->str();
20517   }
20518 }
20519
20520 inline flatbuffers::Offset<VarHandleOptions>
20521 VarHandleOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o,
20522                        const flatbuffers::rehasher_function_t *_rehasher)
20523 {
20524   return CreateVarHandleOptions(_fbb, _o, _rehasher);
20525 }
20526
20527 inline flatbuffers::Offset<VarHandleOptions>
20528 CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o,
20529                        const flatbuffers::rehasher_function_t *_rehasher)
20530 {
20531   (void)_rehasher;
20532   (void)_o;
20533   struct _VectorArgs
20534   {
20535     flatbuffers::FlatBufferBuilder *__fbb;
20536     const VarHandleOptionsT *__o;
20537     const flatbuffers::rehasher_function_t *__rehasher;
20538   } _va = {&_fbb, _o, _rehasher};
20539   (void)_va;
20540   auto _container = _o->container.empty() ? 0 : _fbb.CreateString(_o->container);
20541   auto _shared_name = _o->shared_name.empty() ? 0 : _fbb.CreateString(_o->shared_name);
20542   return circle::CreateVarHandleOptions(_fbb, _container, _shared_name);
20543 }
20544
20545 inline ReadVariableOptionsT *
20546 ReadVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20547 {
20548   auto _o = std::unique_ptr<ReadVariableOptionsT>(new ReadVariableOptionsT());
20549   UnPackTo(_o.get(), _resolver);
20550   return _o.release();
20551 }
20552
20553 inline void ReadVariableOptions::UnPackTo(ReadVariableOptionsT *_o,
20554                                           const flatbuffers::resolver_function_t *_resolver) const
20555 {
20556   (void)_o;
20557   (void)_resolver;
20558 }
20559
20560 inline flatbuffers::Offset<ReadVariableOptions>
20561 ReadVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o,
20562                           const flatbuffers::rehasher_function_t *_rehasher)
20563 {
20564   return CreateReadVariableOptions(_fbb, _o, _rehasher);
20565 }
20566
20567 inline flatbuffers::Offset<ReadVariableOptions>
20568 CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o,
20569                           const flatbuffers::rehasher_function_t *_rehasher)
20570 {
20571   (void)_rehasher;
20572   (void)_o;
20573   struct _VectorArgs
20574   {
20575     flatbuffers::FlatBufferBuilder *__fbb;
20576     const ReadVariableOptionsT *__o;
20577     const flatbuffers::rehasher_function_t *__rehasher;
20578   } _va = {&_fbb, _o, _rehasher};
20579   (void)_va;
20580   return circle::CreateReadVariableOptions(_fbb);
20581 }
20582
20583 inline AssignVariableOptionsT *
20584 AssignVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20585 {
20586   auto _o = std::unique_ptr<AssignVariableOptionsT>(new AssignVariableOptionsT());
20587   UnPackTo(_o.get(), _resolver);
20588   return _o.release();
20589 }
20590
20591 inline void AssignVariableOptions::UnPackTo(AssignVariableOptionsT *_o,
20592                                             const flatbuffers::resolver_function_t *_resolver) const
20593 {
20594   (void)_o;
20595   (void)_resolver;
20596 }
20597
20598 inline flatbuffers::Offset<AssignVariableOptions>
20599 AssignVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o,
20600                             const flatbuffers::rehasher_function_t *_rehasher)
20601 {
20602   return CreateAssignVariableOptions(_fbb, _o, _rehasher);
20603 }
20604
20605 inline flatbuffers::Offset<AssignVariableOptions>
20606 CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o,
20607                             const flatbuffers::rehasher_function_t *_rehasher)
20608 {
20609   (void)_rehasher;
20610   (void)_o;
20611   struct _VectorArgs
20612   {
20613     flatbuffers::FlatBufferBuilder *__fbb;
20614     const AssignVariableOptionsT *__o;
20615     const flatbuffers::rehasher_function_t *__rehasher;
20616   } _va = {&_fbb, _o, _rehasher};
20617   (void)_va;
20618   return circle::CreateAssignVariableOptions(_fbb);
20619 }
20620
20621 inline RandomOptionsT *
20622 RandomOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20623 {
20624   auto _o = std::unique_ptr<RandomOptionsT>(new RandomOptionsT());
20625   UnPackTo(_o.get(), _resolver);
20626   return _o.release();
20627 }
20628
20629 inline void RandomOptions::UnPackTo(RandomOptionsT *_o,
20630                                     const flatbuffers::resolver_function_t *_resolver) const
20631 {
20632   (void)_o;
20633   (void)_resolver;
20634   {
20635     auto _e = seed();
20636     _o->seed = _e;
20637   }
20638   {
20639     auto _e = seed2();
20640     _o->seed2 = _e;
20641   }
20642 }
20643
20644 inline flatbuffers::Offset<RandomOptions>
20645 RandomOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o,
20646                     const flatbuffers::rehasher_function_t *_rehasher)
20647 {
20648   return CreateRandomOptions(_fbb, _o, _rehasher);
20649 }
20650
20651 inline flatbuffers::Offset<RandomOptions>
20652 CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o,
20653                     const flatbuffers::rehasher_function_t *_rehasher)
20654 {
20655   (void)_rehasher;
20656   (void)_o;
20657   struct _VectorArgs
20658   {
20659     flatbuffers::FlatBufferBuilder *__fbb;
20660     const RandomOptionsT *__o;
20661     const flatbuffers::rehasher_function_t *__rehasher;
20662   } _va = {&_fbb, _o, _rehasher};
20663   (void)_va;
20664   auto _seed = _o->seed;
20665   auto _seed2 = _o->seed2;
20666   return circle::CreateRandomOptions(_fbb, _seed, _seed2);
20667 }
20668
20669 inline BCQGatherOptionsT *
20670 BCQGatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20671 {
20672   auto _o = std::unique_ptr<BCQGatherOptionsT>(new BCQGatherOptionsT());
20673   UnPackTo(_o.get(), _resolver);
20674   return _o.release();
20675 }
20676
20677 inline void BCQGatherOptions::UnPackTo(BCQGatherOptionsT *_o,
20678                                        const flatbuffers::resolver_function_t *_resolver) const
20679 {
20680   (void)_o;
20681   (void)_resolver;
20682   {
20683     auto _e = input_hidden_size();
20684     _o->input_hidden_size = _e;
20685   }
20686   {
20687     auto _e = axis();
20688     _o->axis = _e;
20689   }
20690 }
20691
20692 inline flatbuffers::Offset<BCQGatherOptions>
20693 BCQGatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BCQGatherOptionsT *_o,
20694                        const flatbuffers::rehasher_function_t *_rehasher)
20695 {
20696   return CreateBCQGatherOptions(_fbb, _o, _rehasher);
20697 }
20698
20699 inline flatbuffers::Offset<BCQGatherOptions>
20700 CreateBCQGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const BCQGatherOptionsT *_o,
20701                        const flatbuffers::rehasher_function_t *_rehasher)
20702 {
20703   (void)_rehasher;
20704   (void)_o;
20705   struct _VectorArgs
20706   {
20707     flatbuffers::FlatBufferBuilder *__fbb;
20708     const BCQGatherOptionsT *__o;
20709     const flatbuffers::rehasher_function_t *__rehasher;
20710   } _va = {&_fbb, _o, _rehasher};
20711   (void)_va;
20712   auto _input_hidden_size = _o->input_hidden_size;
20713   auto _axis = _o->axis;
20714   return circle::CreateBCQGatherOptions(_fbb, _input_hidden_size, _axis);
20715 }
20716
20717 inline BCQFullyConnectedOptionsT *
20718 BCQFullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20719 {
20720   auto _o = std::unique_ptr<BCQFullyConnectedOptionsT>(new BCQFullyConnectedOptionsT());
20721   UnPackTo(_o.get(), _resolver);
20722   return _o.release();
20723 }
20724
20725 inline void
20726 BCQFullyConnectedOptions::UnPackTo(BCQFullyConnectedOptionsT *_o,
20727                                    const flatbuffers::resolver_function_t *_resolver) const
20728 {
20729   (void)_o;
20730   (void)_resolver;
20731   {
20732     auto _e = weights_hidden_size();
20733     _o->weights_hidden_size = _e;
20734   }
20735   {
20736     auto _e = fused_activation_function();
20737     _o->fused_activation_function = _e;
20738   }
20739 }
20740
20741 inline flatbuffers::Offset<BCQFullyConnectedOptions>
20742 BCQFullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb,
20743                                const BCQFullyConnectedOptionsT *_o,
20744                                const flatbuffers::rehasher_function_t *_rehasher)
20745 {
20746   return CreateBCQFullyConnectedOptions(_fbb, _o, _rehasher);
20747 }
20748
20749 inline flatbuffers::Offset<BCQFullyConnectedOptions>
20750 CreateBCQFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb,
20751                                const BCQFullyConnectedOptionsT *_o,
20752                                const flatbuffers::rehasher_function_t *_rehasher)
20753 {
20754   (void)_rehasher;
20755   (void)_o;
20756   struct _VectorArgs
20757   {
20758     flatbuffers::FlatBufferBuilder *__fbb;
20759     const BCQFullyConnectedOptionsT *__o;
20760     const flatbuffers::rehasher_function_t *__rehasher;
20761   } _va = {&_fbb, _o, _rehasher};
20762   (void)_va;
20763   auto _weights_hidden_size = _o->weights_hidden_size;
20764   auto _fused_activation_function = _o->fused_activation_function;
20765   return circle::CreateBCQFullyConnectedOptions(_fbb, _weights_hidden_size,
20766                                                 _fused_activation_function);
20767 }
20768
20769 inline InstanceNormOptionsT *
20770 InstanceNormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20771 {
20772   auto _o = std::unique_ptr<InstanceNormOptionsT>(new InstanceNormOptionsT());
20773   UnPackTo(_o.get(), _resolver);
20774   return _o.release();
20775 }
20776
20777 inline void InstanceNormOptions::UnPackTo(InstanceNormOptionsT *_o,
20778                                           const flatbuffers::resolver_function_t *_resolver) const
20779 {
20780   (void)_o;
20781   (void)_resolver;
20782   {
20783     auto _e = epsilon();
20784     _o->epsilon = _e;
20785   }
20786   {
20787     auto _e = fused_activation_function();
20788     _o->fused_activation_function = _e;
20789   }
20790 }
20791
20792 inline flatbuffers::Offset<InstanceNormOptions>
20793 InstanceNormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InstanceNormOptionsT *_o,
20794                           const flatbuffers::rehasher_function_t *_rehasher)
20795 {
20796   return CreateInstanceNormOptions(_fbb, _o, _rehasher);
20797 }
20798
20799 inline flatbuffers::Offset<InstanceNormOptions>
20800 CreateInstanceNormOptions(flatbuffers::FlatBufferBuilder &_fbb, const InstanceNormOptionsT *_o,
20801                           const flatbuffers::rehasher_function_t *_rehasher)
20802 {
20803   (void)_rehasher;
20804   (void)_o;
20805   struct _VectorArgs
20806   {
20807     flatbuffers::FlatBufferBuilder *__fbb;
20808     const InstanceNormOptionsT *__o;
20809     const flatbuffers::rehasher_function_t *__rehasher;
20810   } _va = {&_fbb, _o, _rehasher};
20811   (void)_va;
20812   auto _epsilon = _o->epsilon;
20813   auto _fused_activation_function = _o->fused_activation_function;
20814   return circle::CreateInstanceNormOptions(_fbb, _epsilon, _fused_activation_function);
20815 }
20816
20817 inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20818 {
20819   auto _o = std::unique_ptr<OperatorCodeT>(new OperatorCodeT());
20820   UnPackTo(_o.get(), _resolver);
20821   return _o.release();
20822 }
20823
20824 inline void OperatorCode::UnPackTo(OperatorCodeT *_o,
20825                                    const flatbuffers::resolver_function_t *_resolver) const
20826 {
20827   (void)_o;
20828   (void)_resolver;
20829   {
20830     auto _e = deprecated_builtin_code();
20831     _o->deprecated_builtin_code = _e;
20832   }
20833   {
20834     auto _e = custom_code();
20835     if (_e)
20836       _o->custom_code = _e->str();
20837   }
20838   {
20839     auto _e = version();
20840     _o->version = _e;
20841   }
20842   {
20843     auto _e = builtin_code();
20844     _o->builtin_code = _e;
20845   }
20846 }
20847
20848 inline flatbuffers::Offset<OperatorCode>
20849 OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o,
20850                    const flatbuffers::rehasher_function_t *_rehasher)
20851 {
20852   return CreateOperatorCode(_fbb, _o, _rehasher);
20853 }
20854
20855 inline flatbuffers::Offset<OperatorCode>
20856 CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o,
20857                    const flatbuffers::rehasher_function_t *_rehasher)
20858 {
20859   (void)_rehasher;
20860   (void)_o;
20861   struct _VectorArgs
20862   {
20863     flatbuffers::FlatBufferBuilder *__fbb;
20864     const OperatorCodeT *__o;
20865     const flatbuffers::rehasher_function_t *__rehasher;
20866   } _va = {&_fbb, _o, _rehasher};
20867   (void)_va;
20868   auto _deprecated_builtin_code = _o->deprecated_builtin_code;
20869   auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
20870   auto _version = _o->version;
20871   auto _builtin_code = _o->builtin_code;
20872   return circle::CreateOperatorCode(_fbb, _deprecated_builtin_code, _custom_code, _version,
20873                                     _builtin_code);
20874 }
20875
20876 inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20877 {
20878   auto _o = std::unique_ptr<OperatorT>(new OperatorT());
20879   UnPackTo(_o.get(), _resolver);
20880   return _o.release();
20881 }
20882
20883 inline void Operator::UnPackTo(OperatorT *_o,
20884                                const flatbuffers::resolver_function_t *_resolver) const
20885 {
20886   (void)_o;
20887   (void)_resolver;
20888   {
20889     auto _e = opcode_index();
20890     _o->opcode_index = _e;
20891   }
20892   {
20893     auto _e = inputs();
20894     if (_e)
20895     {
20896       _o->inputs.resize(_e->size());
20897       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
20898       {
20899         _o->inputs[_i] = _e->Get(_i);
20900       }
20901     }
20902   }
20903   {
20904     auto _e = outputs();
20905     if (_e)
20906     {
20907       _o->outputs.resize(_e->size());
20908       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
20909       {
20910         _o->outputs[_i] = _e->Get(_i);
20911       }
20912     }
20913   }
20914   {
20915     auto _e = builtin_options_type();
20916     _o->builtin_options.type = _e;
20917   }
20918   {
20919     auto _e = builtin_options();
20920     if (_e)
20921       _o->builtin_options.value =
20922         circle::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver);
20923   }
20924   {
20925     auto _e = custom_options();
20926     if (_e)
20927     {
20928       _o->custom_options.resize(_e->size());
20929       std::copy(_e->begin(), _e->end(), _o->custom_options.begin());
20930     }
20931   }
20932   {
20933     auto _e = custom_options_format();
20934     _o->custom_options_format = _e;
20935   }
20936   {
20937     auto _e = mutating_variable_inputs();
20938     if (_e)
20939     {
20940       _o->mutating_variable_inputs.resize(_e->size());
20941       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
20942       {
20943         _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0;
20944       }
20945     }
20946   }
20947   {
20948     auto _e = intermediates();
20949     if (_e)
20950     {
20951       _o->intermediates.resize(_e->size());
20952       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
20953       {
20954         _o->intermediates[_i] = _e->Get(_i);
20955       }
20956     }
20957   }
20958 }
20959
20960 inline flatbuffers::Offset<Operator>
20961 Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o,
20962                const flatbuffers::rehasher_function_t *_rehasher)
20963 {
20964   return CreateOperator(_fbb, _o, _rehasher);
20965 }
20966
20967 inline flatbuffers::Offset<Operator>
20968 CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o,
20969                const flatbuffers::rehasher_function_t *_rehasher)
20970 {
20971   (void)_rehasher;
20972   (void)_o;
20973   struct _VectorArgs
20974   {
20975     flatbuffers::FlatBufferBuilder *__fbb;
20976     const OperatorT *__o;
20977     const flatbuffers::rehasher_function_t *__rehasher;
20978   } _va = {&_fbb, _o, _rehasher};
20979   (void)_va;
20980   auto _opcode_index = _o->opcode_index;
20981   auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
20982   auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
20983   auto _builtin_options_type = _o->builtin_options.type;
20984   auto _builtin_options = _o->builtin_options.Pack(_fbb);
20985   auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
20986   auto _custom_options_format = _o->custom_options_format;
20987   auto _mutating_variable_inputs =
20988     _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : 0;
20989   auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : 0;
20990   return circle::CreateOperator(_fbb, _opcode_index, _inputs, _outputs, _builtin_options_type,
20991                                 _builtin_options, _custom_options, _custom_options_format,
20992                                 _mutating_variable_inputs, _intermediates);
20993 }
20994
20995 inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const
20996 {
20997   auto _o = std::unique_ptr<SubGraphT>(new SubGraphT());
20998   UnPackTo(_o.get(), _resolver);
20999   return _o.release();
21000 }
21001
21002 inline void SubGraph::UnPackTo(SubGraphT *_o,
21003                                const flatbuffers::resolver_function_t *_resolver) const
21004 {
21005   (void)_o;
21006   (void)_resolver;
21007   {
21008     auto _e = tensors();
21009     if (_e)
21010     {
21011       _o->tensors.resize(_e->size());
21012       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21013       {
21014         _o->tensors[_i] = std::unique_ptr<circle::TensorT>(_e->Get(_i)->UnPack(_resolver));
21015       }
21016     }
21017   }
21018   {
21019     auto _e = inputs();
21020     if (_e)
21021     {
21022       _o->inputs.resize(_e->size());
21023       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21024       {
21025         _o->inputs[_i] = _e->Get(_i);
21026       }
21027     }
21028   }
21029   {
21030     auto _e = outputs();
21031     if (_e)
21032     {
21033       _o->outputs.resize(_e->size());
21034       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21035       {
21036         _o->outputs[_i] = _e->Get(_i);
21037       }
21038     }
21039   }
21040   {
21041     auto _e = operators();
21042     if (_e)
21043     {
21044       _o->operators.resize(_e->size());
21045       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21046       {
21047         _o->operators[_i] = std::unique_ptr<circle::OperatorT>(_e->Get(_i)->UnPack(_resolver));
21048       }
21049     }
21050   }
21051   {
21052     auto _e = name();
21053     if (_e)
21054       _o->name = _e->str();
21055   }
21056   {
21057     auto _e = data_format();
21058     _o->data_format = _e;
21059   }
21060 }
21061
21062 inline flatbuffers::Offset<SubGraph>
21063 SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o,
21064                const flatbuffers::rehasher_function_t *_rehasher)
21065 {
21066   return CreateSubGraph(_fbb, _o, _rehasher);
21067 }
21068
21069 inline flatbuffers::Offset<SubGraph>
21070 CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o,
21071                const flatbuffers::rehasher_function_t *_rehasher)
21072 {
21073   (void)_rehasher;
21074   (void)_o;
21075   struct _VectorArgs
21076   {
21077     flatbuffers::FlatBufferBuilder *__fbb;
21078     const SubGraphT *__o;
21079     const flatbuffers::rehasher_function_t *__rehasher;
21080   } _va = {&_fbb, _o, _rehasher};
21081   (void)_va;
21082   auto _tensors =
21083     _o->tensors.size()
21084       ? _fbb.CreateVector<flatbuffers::Offset<circle::Tensor>>(
21085           _o->tensors.size(),
21086           [](size_t i, _VectorArgs *__va) {
21087             return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher);
21088           },
21089           &_va)
21090       : 0;
21091   auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
21092   auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
21093   auto _operators =
21094     _o->operators.size()
21095       ? _fbb.CreateVector<flatbuffers::Offset<circle::Operator>>(
21096           _o->operators.size(),
21097           [](size_t i, _VectorArgs *__va) {
21098             return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher);
21099           },
21100           &_va)
21101       : 0;
21102   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
21103   auto _data_format = _o->data_format;
21104   return circle::CreateSubGraph(_fbb, _tensors, _inputs, _outputs, _operators, _name, _data_format);
21105 }
21106
21107 inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const
21108 {
21109   auto _o = std::unique_ptr<BufferT>(new BufferT());
21110   UnPackTo(_o.get(), _resolver);
21111   return _o.release();
21112 }
21113
21114 inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const
21115 {
21116   (void)_o;
21117   (void)_resolver;
21118   {
21119     auto _e = data();
21120     if (_e)
21121     {
21122       _o->data.resize(_e->size());
21123       std::copy(_e->begin(), _e->end(), _o->data.begin());
21124     }
21125   }
21126 }
21127
21128 inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb,
21129                                                 const BufferT *_o,
21130                                                 const flatbuffers::rehasher_function_t *_rehasher)
21131 {
21132   return CreateBuffer(_fbb, _o, _rehasher);
21133 }
21134
21135 inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb,
21136                                                 const BufferT *_o,
21137                                                 const flatbuffers::rehasher_function_t *_rehasher)
21138 {
21139   (void)_rehasher;
21140   (void)_o;
21141   struct _VectorArgs
21142   {
21143     flatbuffers::FlatBufferBuilder *__fbb;
21144     const BufferT *__o;
21145     const flatbuffers::rehasher_function_t *__rehasher;
21146   } _va = {&_fbb, _o, _rehasher};
21147   (void)_va;
21148   _fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), 16);
21149   auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
21150   return circle::CreateBuffer(_fbb, _data);
21151 }
21152
21153 inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const
21154 {
21155   auto _o = std::unique_ptr<MetadataT>(new MetadataT());
21156   UnPackTo(_o.get(), _resolver);
21157   return _o.release();
21158 }
21159
21160 inline void Metadata::UnPackTo(MetadataT *_o,
21161                                const flatbuffers::resolver_function_t *_resolver) const
21162 {
21163   (void)_o;
21164   (void)_resolver;
21165   {
21166     auto _e = name();
21167     if (_e)
21168       _o->name = _e->str();
21169   }
21170   {
21171     auto _e = buffer();
21172     _o->buffer = _e;
21173   }
21174 }
21175
21176 inline flatbuffers::Offset<Metadata>
21177 Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o,
21178                const flatbuffers::rehasher_function_t *_rehasher)
21179 {
21180   return CreateMetadata(_fbb, _o, _rehasher);
21181 }
21182
21183 inline flatbuffers::Offset<Metadata>
21184 CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o,
21185                const flatbuffers::rehasher_function_t *_rehasher)
21186 {
21187   (void)_rehasher;
21188   (void)_o;
21189   struct _VectorArgs
21190   {
21191     flatbuffers::FlatBufferBuilder *__fbb;
21192     const MetadataT *__o;
21193     const flatbuffers::rehasher_function_t *__rehasher;
21194   } _va = {&_fbb, _o, _rehasher};
21195   (void)_va;
21196   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
21197   auto _buffer = _o->buffer;
21198   return circle::CreateMetadata(_fbb, _name, _buffer);
21199 }
21200
21201 inline TensorMapT *TensorMap::UnPack(const flatbuffers::resolver_function_t *_resolver) const
21202 {
21203   auto _o = std::unique_ptr<TensorMapT>(new TensorMapT());
21204   UnPackTo(_o.get(), _resolver);
21205   return _o.release();
21206 }
21207
21208 inline void TensorMap::UnPackTo(TensorMapT *_o,
21209                                 const flatbuffers::resolver_function_t *_resolver) const
21210 {
21211   (void)_o;
21212   (void)_resolver;
21213   {
21214     auto _e = name();
21215     if (_e)
21216       _o->name = _e->str();
21217   }
21218   {
21219     auto _e = tensor_index();
21220     _o->tensor_index = _e;
21221   }
21222 }
21223
21224 inline flatbuffers::Offset<TensorMap>
21225 TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o,
21226                 const flatbuffers::rehasher_function_t *_rehasher)
21227 {
21228   return CreateTensorMap(_fbb, _o, _rehasher);
21229 }
21230
21231 inline flatbuffers::Offset<TensorMap>
21232 CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o,
21233                 const flatbuffers::rehasher_function_t *_rehasher)
21234 {
21235   (void)_rehasher;
21236   (void)_o;
21237   struct _VectorArgs
21238   {
21239     flatbuffers::FlatBufferBuilder *__fbb;
21240     const TensorMapT *__o;
21241     const flatbuffers::rehasher_function_t *__rehasher;
21242   } _va = {&_fbb, _o, _rehasher};
21243   (void)_va;
21244   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
21245   auto _tensor_index = _o->tensor_index;
21246   return circle::CreateTensorMap(_fbb, _name, _tensor_index);
21247 }
21248
21249 inline SignatureDefT *SignatureDef::UnPack(const flatbuffers::resolver_function_t *_resolver) const
21250 {
21251   auto _o = std::unique_ptr<SignatureDefT>(new SignatureDefT());
21252   UnPackTo(_o.get(), _resolver);
21253   return _o.release();
21254 }
21255
21256 inline void SignatureDef::UnPackTo(SignatureDefT *_o,
21257                                    const flatbuffers::resolver_function_t *_resolver) const
21258 {
21259   (void)_o;
21260   (void)_resolver;
21261   {
21262     auto _e = inputs();
21263     if (_e)
21264     {
21265       _o->inputs.resize(_e->size());
21266       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21267       {
21268         _o->inputs[_i] = std::unique_ptr<circle::TensorMapT>(_e->Get(_i)->UnPack(_resolver));
21269       }
21270     }
21271   }
21272   {
21273     auto _e = outputs();
21274     if (_e)
21275     {
21276       _o->outputs.resize(_e->size());
21277       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21278       {
21279         _o->outputs[_i] = std::unique_ptr<circle::TensorMapT>(_e->Get(_i)->UnPack(_resolver));
21280       }
21281     }
21282   }
21283   {
21284     auto _e = signature_key();
21285     if (_e)
21286       _o->signature_key = _e->str();
21287   }
21288   {
21289     auto _e = subgraph_index();
21290     _o->subgraph_index = _e;
21291   }
21292 }
21293
21294 inline flatbuffers::Offset<SignatureDef>
21295 SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o,
21296                    const flatbuffers::rehasher_function_t *_rehasher)
21297 {
21298   return CreateSignatureDef(_fbb, _o, _rehasher);
21299 }
21300
21301 inline flatbuffers::Offset<SignatureDef>
21302 CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o,
21303                    const flatbuffers::rehasher_function_t *_rehasher)
21304 {
21305   (void)_rehasher;
21306   (void)_o;
21307   struct _VectorArgs
21308   {
21309     flatbuffers::FlatBufferBuilder *__fbb;
21310     const SignatureDefT *__o;
21311     const flatbuffers::rehasher_function_t *__rehasher;
21312   } _va = {&_fbb, _o, _rehasher};
21313   (void)_va;
21314   auto _inputs =
21315     _o->inputs.size()
21316       ? _fbb.CreateVector<flatbuffers::Offset<circle::TensorMap>>(
21317           _o->inputs.size(),
21318           [](size_t i, _VectorArgs *__va) {
21319             return CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher);
21320           },
21321           &_va)
21322       : 0;
21323   auto _outputs =
21324     _o->outputs.size()
21325       ? _fbb.CreateVector<flatbuffers::Offset<circle::TensorMap>>(
21326           _o->outputs.size(),
21327           [](size_t i, _VectorArgs *__va) {
21328             return CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher);
21329           },
21330           &_va)
21331       : 0;
21332   auto _signature_key = _o->signature_key.empty() ? 0 : _fbb.CreateString(_o->signature_key);
21333   auto _subgraph_index = _o->subgraph_index;
21334   return circle::CreateSignatureDef(_fbb, _inputs, _outputs, _signature_key, _subgraph_index);
21335 }
21336
21337 inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const
21338 {
21339   auto _o = std::unique_ptr<ModelT>(new ModelT());
21340   UnPackTo(_o.get(), _resolver);
21341   return _o.release();
21342 }
21343
21344 inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const
21345 {
21346   (void)_o;
21347   (void)_resolver;
21348   {
21349     auto _e = version();
21350     _o->version = _e;
21351   }
21352   {
21353     auto _e = operator_codes();
21354     if (_e)
21355     {
21356       _o->operator_codes.resize(_e->size());
21357       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21358       {
21359         _o->operator_codes[_i] =
21360           std::unique_ptr<circle::OperatorCodeT>(_e->Get(_i)->UnPack(_resolver));
21361       }
21362     }
21363   }
21364   {
21365     auto _e = subgraphs();
21366     if (_e)
21367     {
21368       _o->subgraphs.resize(_e->size());
21369       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21370       {
21371         _o->subgraphs[_i] = std::unique_ptr<circle::SubGraphT>(_e->Get(_i)->UnPack(_resolver));
21372       }
21373     }
21374   }
21375   {
21376     auto _e = description();
21377     if (_e)
21378       _o->description = _e->str();
21379   }
21380   {
21381     auto _e = buffers();
21382     if (_e)
21383     {
21384       _o->buffers.resize(_e->size());
21385       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21386       {
21387         _o->buffers[_i] = std::unique_ptr<circle::BufferT>(_e->Get(_i)->UnPack(_resolver));
21388       }
21389     }
21390   }
21391   {
21392     auto _e = metadata_buffer();
21393     if (_e)
21394     {
21395       _o->metadata_buffer.resize(_e->size());
21396       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21397       {
21398         _o->metadata_buffer[_i] = _e->Get(_i);
21399       }
21400     }
21401   }
21402   {
21403     auto _e = metadata();
21404     if (_e)
21405     {
21406       _o->metadata.resize(_e->size());
21407       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21408       {
21409         _o->metadata[_i] = std::unique_ptr<circle::MetadataT>(_e->Get(_i)->UnPack(_resolver));
21410       }
21411     }
21412   }
21413   {
21414     auto _e = signature_defs();
21415     if (_e)
21416     {
21417       _o->signature_defs.resize(_e->size());
21418       for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++)
21419       {
21420         _o->signature_defs[_i] =
21421           std::unique_ptr<circle::SignatureDefT>(_e->Get(_i)->UnPack(_resolver));
21422       }
21423     }
21424   }
21425 }
21426
21427 inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb,
21428                                               const ModelT *_o,
21429                                               const flatbuffers::rehasher_function_t *_rehasher)
21430 {
21431   return CreateModel(_fbb, _o, _rehasher);
21432 }
21433
21434 inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb,
21435                                               const ModelT *_o,
21436                                               const flatbuffers::rehasher_function_t *_rehasher)
21437 {
21438   (void)_rehasher;
21439   (void)_o;
21440   struct _VectorArgs
21441   {
21442     flatbuffers::FlatBufferBuilder *__fbb;
21443     const ModelT *__o;
21444     const flatbuffers::rehasher_function_t *__rehasher;
21445   } _va = {&_fbb, _o, _rehasher};
21446   (void)_va;
21447   auto _version = _o->version;
21448   auto _operator_codes =
21449     _o->operator_codes.size()
21450       ? _fbb.CreateVector<flatbuffers::Offset<circle::OperatorCode>>(
21451           _o->operator_codes.size(),
21452           [](size_t i, _VectorArgs *__va) {
21453             return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(),
21454                                       __va->__rehasher);
21455           },
21456           &_va)
21457       : 0;
21458   auto _subgraphs =
21459     _o->subgraphs.size()
21460       ? _fbb.CreateVector<flatbuffers::Offset<circle::SubGraph>>(
21461           _o->subgraphs.size(),
21462           [](size_t i, _VectorArgs *__va) {
21463             return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher);
21464           },
21465           &_va)
21466       : 0;
21467   auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
21468   auto _buffers =
21469     _o->buffers.size()
21470       ? _fbb.CreateVector<flatbuffers::Offset<circle::Buffer>>(
21471           _o->buffers.size(),
21472           [](size_t i, _VectorArgs *__va) {
21473             return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher);
21474           },
21475           &_va)
21476       : 0;
21477   auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0;
21478   auto _metadata =
21479     _o->metadata.size()
21480       ? _fbb.CreateVector<flatbuffers::Offset<circle::Metadata>>(
21481           _o->metadata.size(),
21482           [](size_t i, _VectorArgs *__va) {
21483             return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher);
21484           },
21485           &_va)
21486       : 0;
21487   auto _signature_defs =
21488     _o->signature_defs.size()
21489       ? _fbb.CreateVector<flatbuffers::Offset<circle::SignatureDef>>(
21490           _o->signature_defs.size(),
21491           [](size_t i, _VectorArgs *__va) {
21492             return CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(),
21493                                       __va->__rehasher);
21494           },
21495           &_va)
21496       : 0;
21497   return circle::CreateModel(_fbb, _version, _operator_codes, _subgraphs, _description, _buffers,
21498                              _metadata_buffer, _metadata, _signature_defs);
21499 }
21500
21501 inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj,
21502                                       QuantizationDetails type)
21503 {
21504   switch (type)
21505   {
21506     case QuantizationDetails_NONE:
21507     {
21508       return true;
21509     }
21510     case QuantizationDetails_CustomQuantization:
21511     {
21512       auto ptr = reinterpret_cast<const circle::CustomQuantization *>(obj);
21513       return verifier.VerifyTable(ptr);
21514     }
21515     default:
21516       return true;
21517   }
21518 }
21519
21520 inline bool
21521 VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier,
21522                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
21523                                 const flatbuffers::Vector<uint8_t> *types)
21524 {
21525   if (!values || !types)
21526     return !values && !types;
21527   if (values->size() != types->size())
21528     return false;
21529   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
21530   {
21531     if (!VerifyQuantizationDetails(verifier, values->Get(i),
21532                                    types->GetEnum<QuantizationDetails>(i)))
21533     {
21534       return false;
21535     }
21536   }
21537   return true;
21538 }
21539
21540 inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type,
21541                                               const flatbuffers::resolver_function_t *resolver)
21542 {
21543   switch (type)
21544   {
21545     case QuantizationDetails_CustomQuantization:
21546     {
21547       auto ptr = reinterpret_cast<const circle::CustomQuantization *>(obj);
21548       return ptr->UnPack(resolver);
21549     }
21550     default:
21551       return nullptr;
21552   }
21553 }
21554
21555 inline flatbuffers::Offset<void>
21556 QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb,
21557                                const flatbuffers::rehasher_function_t *_rehasher) const
21558 {
21559   switch (type)
21560   {
21561     case QuantizationDetails_CustomQuantization:
21562     {
21563       auto ptr = reinterpret_cast<const circle::CustomQuantizationT *>(value);
21564       return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
21565     }
21566     default:
21567       return 0;
21568   }
21569 }
21570
21571 inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u)
21572   : type(u.type), value(nullptr)
21573 {
21574   switch (type)
21575   {
21576     case QuantizationDetails_CustomQuantization:
21577     {
21578       value =
21579         new circle::CustomQuantizationT(*reinterpret_cast<circle::CustomQuantizationT *>(u.value));
21580       break;
21581     }
21582     default:
21583       break;
21584   }
21585 }
21586
21587 inline void QuantizationDetailsUnion::Reset()
21588 {
21589   switch (type)
21590   {
21591     case QuantizationDetails_CustomQuantization:
21592     {
21593       auto ptr = reinterpret_cast<circle::CustomQuantizationT *>(value);
21594       delete ptr;
21595       break;
21596     }
21597     default:
21598       break;
21599   }
21600   value = nullptr;
21601   type = QuantizationDetails_NONE;
21602 }
21603
21604 inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj,
21605                                     SparseIndexVector type)
21606 {
21607   switch (type)
21608   {
21609     case SparseIndexVector_NONE:
21610     {
21611       return true;
21612     }
21613     case SparseIndexVector_Int32Vector:
21614     {
21615       auto ptr = reinterpret_cast<const circle::Int32Vector *>(obj);
21616       return verifier.VerifyTable(ptr);
21617     }
21618     case SparseIndexVector_Uint16Vector:
21619     {
21620       auto ptr = reinterpret_cast<const circle::Uint16Vector *>(obj);
21621       return verifier.VerifyTable(ptr);
21622     }
21623     case SparseIndexVector_Uint8Vector:
21624     {
21625       auto ptr = reinterpret_cast<const circle::Uint8Vector *>(obj);
21626       return verifier.VerifyTable(ptr);
21627     }
21628     default:
21629       return true;
21630   }
21631 }
21632
21633 inline bool
21634 VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier,
21635                               const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
21636                               const flatbuffers::Vector<uint8_t> *types)
21637 {
21638   if (!values || !types)
21639     return !values && !types;
21640   if (values->size() != types->size())
21641     return false;
21642   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
21643   {
21644     if (!VerifySparseIndexVector(verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i)))
21645     {
21646       return false;
21647     }
21648   }
21649   return true;
21650 }
21651
21652 inline void *SparseIndexVectorUnion::UnPack(const void *obj, SparseIndexVector type,
21653                                             const flatbuffers::resolver_function_t *resolver)
21654 {
21655   switch (type)
21656   {
21657     case SparseIndexVector_Int32Vector:
21658     {
21659       auto ptr = reinterpret_cast<const circle::Int32Vector *>(obj);
21660       return ptr->UnPack(resolver);
21661     }
21662     case SparseIndexVector_Uint16Vector:
21663     {
21664       auto ptr = reinterpret_cast<const circle::Uint16Vector *>(obj);
21665       return ptr->UnPack(resolver);
21666     }
21667     case SparseIndexVector_Uint8Vector:
21668     {
21669       auto ptr = reinterpret_cast<const circle::Uint8Vector *>(obj);
21670       return ptr->UnPack(resolver);
21671     }
21672     default:
21673       return nullptr;
21674   }
21675 }
21676
21677 inline flatbuffers::Offset<void>
21678 SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb,
21679                              const flatbuffers::rehasher_function_t *_rehasher) const
21680 {
21681   switch (type)
21682   {
21683     case SparseIndexVector_Int32Vector:
21684     {
21685       auto ptr = reinterpret_cast<const circle::Int32VectorT *>(value);
21686       return CreateInt32Vector(_fbb, ptr, _rehasher).Union();
21687     }
21688     case SparseIndexVector_Uint16Vector:
21689     {
21690       auto ptr = reinterpret_cast<const circle::Uint16VectorT *>(value);
21691       return CreateUint16Vector(_fbb, ptr, _rehasher).Union();
21692     }
21693     case SparseIndexVector_Uint8Vector:
21694     {
21695       auto ptr = reinterpret_cast<const circle::Uint8VectorT *>(value);
21696       return CreateUint8Vector(_fbb, ptr, _rehasher).Union();
21697     }
21698     default:
21699       return 0;
21700   }
21701 }
21702
21703 inline SparseIndexVectorUnion::SparseIndexVectorUnion(const SparseIndexVectorUnion &u)
21704   : type(u.type), value(nullptr)
21705 {
21706   switch (type)
21707   {
21708     case SparseIndexVector_Int32Vector:
21709     {
21710       value = new circle::Int32VectorT(*reinterpret_cast<circle::Int32VectorT *>(u.value));
21711       break;
21712     }
21713     case SparseIndexVector_Uint16Vector:
21714     {
21715       value = new circle::Uint16VectorT(*reinterpret_cast<circle::Uint16VectorT *>(u.value));
21716       break;
21717     }
21718     case SparseIndexVector_Uint8Vector:
21719     {
21720       value = new circle::Uint8VectorT(*reinterpret_cast<circle::Uint8VectorT *>(u.value));
21721       break;
21722     }
21723     default:
21724       break;
21725   }
21726 }
21727
21728 inline void SparseIndexVectorUnion::Reset()
21729 {
21730   switch (type)
21731   {
21732     case SparseIndexVector_Int32Vector:
21733     {
21734       auto ptr = reinterpret_cast<circle::Int32VectorT *>(value);
21735       delete ptr;
21736       break;
21737     }
21738     case SparseIndexVector_Uint16Vector:
21739     {
21740       auto ptr = reinterpret_cast<circle::Uint16VectorT *>(value);
21741       delete ptr;
21742       break;
21743     }
21744     case SparseIndexVector_Uint8Vector:
21745     {
21746       auto ptr = reinterpret_cast<circle::Uint8VectorT *>(value);
21747       delete ptr;
21748       break;
21749     }
21750     default:
21751       break;
21752   }
21753   value = nullptr;
21754   type = SparseIndexVector_NONE;
21755 }
21756
21757 inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj,
21758                                  BuiltinOptions type)
21759 {
21760   switch (type)
21761   {
21762     case BuiltinOptions_NONE:
21763     {
21764       return true;
21765     }
21766     case BuiltinOptions_Conv2DOptions:
21767     {
21768       auto ptr = reinterpret_cast<const circle::Conv2DOptions *>(obj);
21769       return verifier.VerifyTable(ptr);
21770     }
21771     case BuiltinOptions_DepthwiseConv2DOptions:
21772     {
21773       auto ptr = reinterpret_cast<const circle::DepthwiseConv2DOptions *>(obj);
21774       return verifier.VerifyTable(ptr);
21775     }
21776     case BuiltinOptions_ConcatEmbeddingsOptions:
21777     {
21778       auto ptr = reinterpret_cast<const circle::ConcatEmbeddingsOptions *>(obj);
21779       return verifier.VerifyTable(ptr);
21780     }
21781     case BuiltinOptions_LSHProjectionOptions:
21782     {
21783       auto ptr = reinterpret_cast<const circle::LSHProjectionOptions *>(obj);
21784       return verifier.VerifyTable(ptr);
21785     }
21786     case BuiltinOptions_Pool2DOptions:
21787     {
21788       auto ptr = reinterpret_cast<const circle::Pool2DOptions *>(obj);
21789       return verifier.VerifyTable(ptr);
21790     }
21791     case BuiltinOptions_SVDFOptions:
21792     {
21793       auto ptr = reinterpret_cast<const circle::SVDFOptions *>(obj);
21794       return verifier.VerifyTable(ptr);
21795     }
21796     case BuiltinOptions_RNNOptions:
21797     {
21798       auto ptr = reinterpret_cast<const circle::RNNOptions *>(obj);
21799       return verifier.VerifyTable(ptr);
21800     }
21801     case BuiltinOptions_FullyConnectedOptions:
21802     {
21803       auto ptr = reinterpret_cast<const circle::FullyConnectedOptions *>(obj);
21804       return verifier.VerifyTable(ptr);
21805     }
21806     case BuiltinOptions_SoftmaxOptions:
21807     {
21808       auto ptr = reinterpret_cast<const circle::SoftmaxOptions *>(obj);
21809       return verifier.VerifyTable(ptr);
21810     }
21811     case BuiltinOptions_ConcatenationOptions:
21812     {
21813       auto ptr = reinterpret_cast<const circle::ConcatenationOptions *>(obj);
21814       return verifier.VerifyTable(ptr);
21815     }
21816     case BuiltinOptions_AddOptions:
21817     {
21818       auto ptr = reinterpret_cast<const circle::AddOptions *>(obj);
21819       return verifier.VerifyTable(ptr);
21820     }
21821     case BuiltinOptions_L2NormOptions:
21822     {
21823       auto ptr = reinterpret_cast<const circle::L2NormOptions *>(obj);
21824       return verifier.VerifyTable(ptr);
21825     }
21826     case BuiltinOptions_LocalResponseNormalizationOptions:
21827     {
21828       auto ptr = reinterpret_cast<const circle::LocalResponseNormalizationOptions *>(obj);
21829       return verifier.VerifyTable(ptr);
21830     }
21831     case BuiltinOptions_LSTMOptions:
21832     {
21833       auto ptr = reinterpret_cast<const circle::LSTMOptions *>(obj);
21834       return verifier.VerifyTable(ptr);
21835     }
21836     case BuiltinOptions_ResizeBilinearOptions:
21837     {
21838       auto ptr = reinterpret_cast<const circle::ResizeBilinearOptions *>(obj);
21839       return verifier.VerifyTable(ptr);
21840     }
21841     case BuiltinOptions_CallOptions:
21842     {
21843       auto ptr = reinterpret_cast<const circle::CallOptions *>(obj);
21844       return verifier.VerifyTable(ptr);
21845     }
21846     case BuiltinOptions_ReshapeOptions:
21847     {
21848       auto ptr = reinterpret_cast<const circle::ReshapeOptions *>(obj);
21849       return verifier.VerifyTable(ptr);
21850     }
21851     case BuiltinOptions_SkipGramOptions:
21852     {
21853       auto ptr = reinterpret_cast<const circle::SkipGramOptions *>(obj);
21854       return verifier.VerifyTable(ptr);
21855     }
21856     case BuiltinOptions_SpaceToDepthOptions:
21857     {
21858       auto ptr = reinterpret_cast<const circle::SpaceToDepthOptions *>(obj);
21859       return verifier.VerifyTable(ptr);
21860     }
21861     case BuiltinOptions_EmbeddingLookupSparseOptions:
21862     {
21863       auto ptr = reinterpret_cast<const circle::EmbeddingLookupSparseOptions *>(obj);
21864       return verifier.VerifyTable(ptr);
21865     }
21866     case BuiltinOptions_MulOptions:
21867     {
21868       auto ptr = reinterpret_cast<const circle::MulOptions *>(obj);
21869       return verifier.VerifyTable(ptr);
21870     }
21871     case BuiltinOptions_PadOptions:
21872     {
21873       auto ptr = reinterpret_cast<const circle::PadOptions *>(obj);
21874       return verifier.VerifyTable(ptr);
21875     }
21876     case BuiltinOptions_GatherOptions:
21877     {
21878       auto ptr = reinterpret_cast<const circle::GatherOptions *>(obj);
21879       return verifier.VerifyTable(ptr);
21880     }
21881     case BuiltinOptions_BatchToSpaceNDOptions:
21882     {
21883       auto ptr = reinterpret_cast<const circle::BatchToSpaceNDOptions *>(obj);
21884       return verifier.VerifyTable(ptr);
21885     }
21886     case BuiltinOptions_SpaceToBatchNDOptions:
21887     {
21888       auto ptr = reinterpret_cast<const circle::SpaceToBatchNDOptions *>(obj);
21889       return verifier.VerifyTable(ptr);
21890     }
21891     case BuiltinOptions_TransposeOptions:
21892     {
21893       auto ptr = reinterpret_cast<const circle::TransposeOptions *>(obj);
21894       return verifier.VerifyTable(ptr);
21895     }
21896     case BuiltinOptions_ReducerOptions:
21897     {
21898       auto ptr = reinterpret_cast<const circle::ReducerOptions *>(obj);
21899       return verifier.VerifyTable(ptr);
21900     }
21901     case BuiltinOptions_SubOptions:
21902     {
21903       auto ptr = reinterpret_cast<const circle::SubOptions *>(obj);
21904       return verifier.VerifyTable(ptr);
21905     }
21906     case BuiltinOptions_DivOptions:
21907     {
21908       auto ptr = reinterpret_cast<const circle::DivOptions *>(obj);
21909       return verifier.VerifyTable(ptr);
21910     }
21911     case BuiltinOptions_SqueezeOptions:
21912     {
21913       auto ptr = reinterpret_cast<const circle::SqueezeOptions *>(obj);
21914       return verifier.VerifyTable(ptr);
21915     }
21916     case BuiltinOptions_SequenceRNNOptions:
21917     {
21918       auto ptr = reinterpret_cast<const circle::SequenceRNNOptions *>(obj);
21919       return verifier.VerifyTable(ptr);
21920     }
21921     case BuiltinOptions_StridedSliceOptions:
21922     {
21923       auto ptr = reinterpret_cast<const circle::StridedSliceOptions *>(obj);
21924       return verifier.VerifyTable(ptr);
21925     }
21926     case BuiltinOptions_ExpOptions:
21927     {
21928       auto ptr = reinterpret_cast<const circle::ExpOptions *>(obj);
21929       return verifier.VerifyTable(ptr);
21930     }
21931     case BuiltinOptions_TopKV2Options:
21932     {
21933       auto ptr = reinterpret_cast<const circle::TopKV2Options *>(obj);
21934       return verifier.VerifyTable(ptr);
21935     }
21936     case BuiltinOptions_SplitOptions:
21937     {
21938       auto ptr = reinterpret_cast<const circle::SplitOptions *>(obj);
21939       return verifier.VerifyTable(ptr);
21940     }
21941     case BuiltinOptions_LogSoftmaxOptions:
21942     {
21943       auto ptr = reinterpret_cast<const circle::LogSoftmaxOptions *>(obj);
21944       return verifier.VerifyTable(ptr);
21945     }
21946     case BuiltinOptions_CastOptions:
21947     {
21948       auto ptr = reinterpret_cast<const circle::CastOptions *>(obj);
21949       return verifier.VerifyTable(ptr);
21950     }
21951     case BuiltinOptions_DequantizeOptions:
21952     {
21953       auto ptr = reinterpret_cast<const circle::DequantizeOptions *>(obj);
21954       return verifier.VerifyTable(ptr);
21955     }
21956     case BuiltinOptions_MaximumMinimumOptions:
21957     {
21958       auto ptr = reinterpret_cast<const circle::MaximumMinimumOptions *>(obj);
21959       return verifier.VerifyTable(ptr);
21960     }
21961     case BuiltinOptions_ArgMaxOptions:
21962     {
21963       auto ptr = reinterpret_cast<const circle::ArgMaxOptions *>(obj);
21964       return verifier.VerifyTable(ptr);
21965     }
21966     case BuiltinOptions_LessOptions:
21967     {
21968       auto ptr = reinterpret_cast<const circle::LessOptions *>(obj);
21969       return verifier.VerifyTable(ptr);
21970     }
21971     case BuiltinOptions_NegOptions:
21972     {
21973       auto ptr = reinterpret_cast<const circle::NegOptions *>(obj);
21974       return verifier.VerifyTable(ptr);
21975     }
21976     case BuiltinOptions_PadV2Options:
21977     {
21978       auto ptr = reinterpret_cast<const circle::PadV2Options *>(obj);
21979       return verifier.VerifyTable(ptr);
21980     }
21981     case BuiltinOptions_GreaterOptions:
21982     {
21983       auto ptr = reinterpret_cast<const circle::GreaterOptions *>(obj);
21984       return verifier.VerifyTable(ptr);
21985     }
21986     case BuiltinOptions_GreaterEqualOptions:
21987     {
21988       auto ptr = reinterpret_cast<const circle::GreaterEqualOptions *>(obj);
21989       return verifier.VerifyTable(ptr);
21990     }
21991     case BuiltinOptions_LessEqualOptions:
21992     {
21993       auto ptr = reinterpret_cast<const circle::LessEqualOptions *>(obj);
21994       return verifier.VerifyTable(ptr);
21995     }
21996     case BuiltinOptions_SelectOptions:
21997     {
21998       auto ptr = reinterpret_cast<const circle::SelectOptions *>(obj);
21999       return verifier.VerifyTable(ptr);
22000     }
22001     case BuiltinOptions_SliceOptions:
22002     {
22003       auto ptr = reinterpret_cast<const circle::SliceOptions *>(obj);
22004       return verifier.VerifyTable(ptr);
22005     }
22006     case BuiltinOptions_TransposeConvOptions:
22007     {
22008       auto ptr = reinterpret_cast<const circle::TransposeConvOptions *>(obj);
22009       return verifier.VerifyTable(ptr);
22010     }
22011     case BuiltinOptions_SparseToDenseOptions:
22012     {
22013       auto ptr = reinterpret_cast<const circle::SparseToDenseOptions *>(obj);
22014       return verifier.VerifyTable(ptr);
22015     }
22016     case BuiltinOptions_TileOptions:
22017     {
22018       auto ptr = reinterpret_cast<const circle::TileOptions *>(obj);
22019       return verifier.VerifyTable(ptr);
22020     }
22021     case BuiltinOptions_ExpandDimsOptions:
22022     {
22023       auto ptr = reinterpret_cast<const circle::ExpandDimsOptions *>(obj);
22024       return verifier.VerifyTable(ptr);
22025     }
22026     case BuiltinOptions_EqualOptions:
22027     {
22028       auto ptr = reinterpret_cast<const circle::EqualOptions *>(obj);
22029       return verifier.VerifyTable(ptr);
22030     }
22031     case BuiltinOptions_NotEqualOptions:
22032     {
22033       auto ptr = reinterpret_cast<const circle::NotEqualOptions *>(obj);
22034       return verifier.VerifyTable(ptr);
22035     }
22036     case BuiltinOptions_ShapeOptions:
22037     {
22038       auto ptr = reinterpret_cast<const circle::ShapeOptions *>(obj);
22039       return verifier.VerifyTable(ptr);
22040     }
22041     case BuiltinOptions_PowOptions:
22042     {
22043       auto ptr = reinterpret_cast<const circle::PowOptions *>(obj);
22044       return verifier.VerifyTable(ptr);
22045     }
22046     case BuiltinOptions_ArgMinOptions:
22047     {
22048       auto ptr = reinterpret_cast<const circle::ArgMinOptions *>(obj);
22049       return verifier.VerifyTable(ptr);
22050     }
22051     case BuiltinOptions_FakeQuantOptions:
22052     {
22053       auto ptr = reinterpret_cast<const circle::FakeQuantOptions *>(obj);
22054       return verifier.VerifyTable(ptr);
22055     }
22056     case BuiltinOptions_PackOptions:
22057     {
22058       auto ptr = reinterpret_cast<const circle::PackOptions *>(obj);
22059       return verifier.VerifyTable(ptr);
22060     }
22061     case BuiltinOptions_LogicalOrOptions:
22062     {
22063       auto ptr = reinterpret_cast<const circle::LogicalOrOptions *>(obj);
22064       return verifier.VerifyTable(ptr);
22065     }
22066     case BuiltinOptions_OneHotOptions:
22067     {
22068       auto ptr = reinterpret_cast<const circle::OneHotOptions *>(obj);
22069       return verifier.VerifyTable(ptr);
22070     }
22071     case BuiltinOptions_LogicalAndOptions:
22072     {
22073       auto ptr = reinterpret_cast<const circle::LogicalAndOptions *>(obj);
22074       return verifier.VerifyTable(ptr);
22075     }
22076     case BuiltinOptions_LogicalNotOptions:
22077     {
22078       auto ptr = reinterpret_cast<const circle::LogicalNotOptions *>(obj);
22079       return verifier.VerifyTable(ptr);
22080     }
22081     case BuiltinOptions_UnpackOptions:
22082     {
22083       auto ptr = reinterpret_cast<const circle::UnpackOptions *>(obj);
22084       return verifier.VerifyTable(ptr);
22085     }
22086     case BuiltinOptions_FloorDivOptions:
22087     {
22088       auto ptr = reinterpret_cast<const circle::FloorDivOptions *>(obj);
22089       return verifier.VerifyTable(ptr);
22090     }
22091     case BuiltinOptions_SquareOptions:
22092     {
22093       auto ptr = reinterpret_cast<const circle::SquareOptions *>(obj);
22094       return verifier.VerifyTable(ptr);
22095     }
22096     case BuiltinOptions_ZerosLikeOptions:
22097     {
22098       auto ptr = reinterpret_cast<const circle::ZerosLikeOptions *>(obj);
22099       return verifier.VerifyTable(ptr);
22100     }
22101     case BuiltinOptions_FillOptions:
22102     {
22103       auto ptr = reinterpret_cast<const circle::FillOptions *>(obj);
22104       return verifier.VerifyTable(ptr);
22105     }
22106     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
22107     {
22108       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceLSTMOptions *>(obj);
22109       return verifier.VerifyTable(ptr);
22110     }
22111     case BuiltinOptions_BidirectionalSequenceRNNOptions:
22112     {
22113       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceRNNOptions *>(obj);
22114       return verifier.VerifyTable(ptr);
22115     }
22116     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
22117     {
22118       auto ptr = reinterpret_cast<const circle::UnidirectionalSequenceLSTMOptions *>(obj);
22119       return verifier.VerifyTable(ptr);
22120     }
22121     case BuiltinOptions_FloorModOptions:
22122     {
22123       auto ptr = reinterpret_cast<const circle::FloorModOptions *>(obj);
22124       return verifier.VerifyTable(ptr);
22125     }
22126     case BuiltinOptions_RangeOptions:
22127     {
22128       auto ptr = reinterpret_cast<const circle::RangeOptions *>(obj);
22129       return verifier.VerifyTable(ptr);
22130     }
22131     case BuiltinOptions_ResizeNearestNeighborOptions:
22132     {
22133       auto ptr = reinterpret_cast<const circle::ResizeNearestNeighborOptions *>(obj);
22134       return verifier.VerifyTable(ptr);
22135     }
22136     case BuiltinOptions_LeakyReluOptions:
22137     {
22138       auto ptr = reinterpret_cast<const circle::LeakyReluOptions *>(obj);
22139       return verifier.VerifyTable(ptr);
22140     }
22141     case BuiltinOptions_SquaredDifferenceOptions:
22142     {
22143       auto ptr = reinterpret_cast<const circle::SquaredDifferenceOptions *>(obj);
22144       return verifier.VerifyTable(ptr);
22145     }
22146     case BuiltinOptions_MirrorPadOptions:
22147     {
22148       auto ptr = reinterpret_cast<const circle::MirrorPadOptions *>(obj);
22149       return verifier.VerifyTable(ptr);
22150     }
22151     case BuiltinOptions_AbsOptions:
22152     {
22153       auto ptr = reinterpret_cast<const circle::AbsOptions *>(obj);
22154       return verifier.VerifyTable(ptr);
22155     }
22156     case BuiltinOptions_SplitVOptions:
22157     {
22158       auto ptr = reinterpret_cast<const circle::SplitVOptions *>(obj);
22159       return verifier.VerifyTable(ptr);
22160     }
22161     case BuiltinOptions_UniqueOptions:
22162     {
22163       auto ptr = reinterpret_cast<const circle::UniqueOptions *>(obj);
22164       return verifier.VerifyTable(ptr);
22165     }
22166     case BuiltinOptions_ReverseV2Options:
22167     {
22168       auto ptr = reinterpret_cast<const circle::ReverseV2Options *>(obj);
22169       return verifier.VerifyTable(ptr);
22170     }
22171     case BuiltinOptions_AddNOptions:
22172     {
22173       auto ptr = reinterpret_cast<const circle::AddNOptions *>(obj);
22174       return verifier.VerifyTable(ptr);
22175     }
22176     case BuiltinOptions_GatherNdOptions:
22177     {
22178       auto ptr = reinterpret_cast<const circle::GatherNdOptions *>(obj);
22179       return verifier.VerifyTable(ptr);
22180     }
22181     case BuiltinOptions_CosOptions:
22182     {
22183       auto ptr = reinterpret_cast<const circle::CosOptions *>(obj);
22184       return verifier.VerifyTable(ptr);
22185     }
22186     case BuiltinOptions_WhereOptions:
22187     {
22188       auto ptr = reinterpret_cast<const circle::WhereOptions *>(obj);
22189       return verifier.VerifyTable(ptr);
22190     }
22191     case BuiltinOptions_RankOptions:
22192     {
22193       auto ptr = reinterpret_cast<const circle::RankOptions *>(obj);
22194       return verifier.VerifyTable(ptr);
22195     }
22196     case BuiltinOptions_ReverseSequenceOptions:
22197     {
22198       auto ptr = reinterpret_cast<const circle::ReverseSequenceOptions *>(obj);
22199       return verifier.VerifyTable(ptr);
22200     }
22201     case BuiltinOptions_MatrixDiagOptions:
22202     {
22203       auto ptr = reinterpret_cast<const circle::MatrixDiagOptions *>(obj);
22204       return verifier.VerifyTable(ptr);
22205     }
22206     case BuiltinOptions_QuantizeOptions:
22207     {
22208       auto ptr = reinterpret_cast<const circle::QuantizeOptions *>(obj);
22209       return verifier.VerifyTable(ptr);
22210     }
22211     case BuiltinOptions_MatrixSetDiagOptions:
22212     {
22213       auto ptr = reinterpret_cast<const circle::MatrixSetDiagOptions *>(obj);
22214       return verifier.VerifyTable(ptr);
22215     }
22216     case BuiltinOptions_HardSwishOptions:
22217     {
22218       auto ptr = reinterpret_cast<const circle::HardSwishOptions *>(obj);
22219       return verifier.VerifyTable(ptr);
22220     }
22221     case BuiltinOptions_IfOptions:
22222     {
22223       auto ptr = reinterpret_cast<const circle::IfOptions *>(obj);
22224       return verifier.VerifyTable(ptr);
22225     }
22226     case BuiltinOptions_WhileOptions:
22227     {
22228       auto ptr = reinterpret_cast<const circle::WhileOptions *>(obj);
22229       return verifier.VerifyTable(ptr);
22230     }
22231     case BuiltinOptions_DepthToSpaceOptions:
22232     {
22233       auto ptr = reinterpret_cast<const circle::DepthToSpaceOptions *>(obj);
22234       return verifier.VerifyTable(ptr);
22235     }
22236     case BuiltinOptions_NonMaxSuppressionV4Options:
22237     {
22238       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV4Options *>(obj);
22239       return verifier.VerifyTable(ptr);
22240     }
22241     case BuiltinOptions_NonMaxSuppressionV5Options:
22242     {
22243       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV5Options *>(obj);
22244       return verifier.VerifyTable(ptr);
22245     }
22246     case BuiltinOptions_ScatterNdOptions:
22247     {
22248       auto ptr = reinterpret_cast<const circle::ScatterNdOptions *>(obj);
22249       return verifier.VerifyTable(ptr);
22250     }
22251     case BuiltinOptions_SelectV2Options:
22252     {
22253       auto ptr = reinterpret_cast<const circle::SelectV2Options *>(obj);
22254       return verifier.VerifyTable(ptr);
22255     }
22256     case BuiltinOptions_DensifyOptions:
22257     {
22258       auto ptr = reinterpret_cast<const circle::DensifyOptions *>(obj);
22259       return verifier.VerifyTable(ptr);
22260     }
22261     case BuiltinOptions_SegmentSumOptions:
22262     {
22263       auto ptr = reinterpret_cast<const circle::SegmentSumOptions *>(obj);
22264       return verifier.VerifyTable(ptr);
22265     }
22266     case BuiltinOptions_BatchMatMulOptions:
22267     {
22268       auto ptr = reinterpret_cast<const circle::BatchMatMulOptions *>(obj);
22269       return verifier.VerifyTable(ptr);
22270     }
22271     case BuiltinOptions_CumsumOptions:
22272     {
22273       auto ptr = reinterpret_cast<const circle::CumsumOptions *>(obj);
22274       return verifier.VerifyTable(ptr);
22275     }
22276     case BuiltinOptions_CallOnceOptions:
22277     {
22278       auto ptr = reinterpret_cast<const circle::CallOnceOptions *>(obj);
22279       return verifier.VerifyTable(ptr);
22280     }
22281     case BuiltinOptions_BroadcastToOptions:
22282     {
22283       auto ptr = reinterpret_cast<const circle::BroadcastToOptions *>(obj);
22284       return verifier.VerifyTable(ptr);
22285     }
22286     case BuiltinOptions_Rfft2dOptions:
22287     {
22288       auto ptr = reinterpret_cast<const circle::Rfft2dOptions *>(obj);
22289       return verifier.VerifyTable(ptr);
22290     }
22291     case BuiltinOptions_Conv3DOptions:
22292     {
22293       auto ptr = reinterpret_cast<const circle::Conv3DOptions *>(obj);
22294       return verifier.VerifyTable(ptr);
22295     }
22296     case BuiltinOptions_HashtableOptions:
22297     {
22298       auto ptr = reinterpret_cast<const circle::HashtableOptions *>(obj);
22299       return verifier.VerifyTable(ptr);
22300     }
22301     case BuiltinOptions_HashtableFindOptions:
22302     {
22303       auto ptr = reinterpret_cast<const circle::HashtableFindOptions *>(obj);
22304       return verifier.VerifyTable(ptr);
22305     }
22306     case BuiltinOptions_HashtableImportOptions:
22307     {
22308       auto ptr = reinterpret_cast<const circle::HashtableImportOptions *>(obj);
22309       return verifier.VerifyTable(ptr);
22310     }
22311     case BuiltinOptions_HashtableSizeOptions:
22312     {
22313       auto ptr = reinterpret_cast<const circle::HashtableSizeOptions *>(obj);
22314       return verifier.VerifyTable(ptr);
22315     }
22316     case BuiltinOptions_VarHandleOptions:
22317     {
22318       auto ptr = reinterpret_cast<const circle::VarHandleOptions *>(obj);
22319       return verifier.VerifyTable(ptr);
22320     }
22321     case BuiltinOptions_ReadVariableOptions:
22322     {
22323       auto ptr = reinterpret_cast<const circle::ReadVariableOptions *>(obj);
22324       return verifier.VerifyTable(ptr);
22325     }
22326     case BuiltinOptions_AssignVariableOptions:
22327     {
22328       auto ptr = reinterpret_cast<const circle::AssignVariableOptions *>(obj);
22329       return verifier.VerifyTable(ptr);
22330     }
22331     case BuiltinOptions_RandomOptions:
22332     {
22333       auto ptr = reinterpret_cast<const circle::RandomOptions *>(obj);
22334       return verifier.VerifyTable(ptr);
22335     }
22336     case BuiltinOptions_BCQGatherOptions:
22337     {
22338       auto ptr = reinterpret_cast<const circle::BCQGatherOptions *>(obj);
22339       return verifier.VerifyTable(ptr);
22340     }
22341     case BuiltinOptions_BCQFullyConnectedOptions:
22342     {
22343       auto ptr = reinterpret_cast<const circle::BCQFullyConnectedOptions *>(obj);
22344       return verifier.VerifyTable(ptr);
22345     }
22346     case BuiltinOptions_InstanceNormOptions:
22347     {
22348       auto ptr = reinterpret_cast<const circle::InstanceNormOptions *>(obj);
22349       return verifier.VerifyTable(ptr);
22350     }
22351     default:
22352       return true;
22353   }
22354 }
22355
22356 inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
22357                                        const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
22358                                        const flatbuffers::Vector<uint8_t> *types)
22359 {
22360   if (!values || !types)
22361     return !values && !types;
22362   if (values->size() != types->size())
22363     return false;
22364   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i)
22365   {
22366     if (!VerifyBuiltinOptions(verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i)))
22367     {
22368       return false;
22369     }
22370   }
22371   return true;
22372 }
22373
22374 inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type,
22375                                          const flatbuffers::resolver_function_t *resolver)
22376 {
22377   switch (type)
22378   {
22379     case BuiltinOptions_Conv2DOptions:
22380     {
22381       auto ptr = reinterpret_cast<const circle::Conv2DOptions *>(obj);
22382       return ptr->UnPack(resolver);
22383     }
22384     case BuiltinOptions_DepthwiseConv2DOptions:
22385     {
22386       auto ptr = reinterpret_cast<const circle::DepthwiseConv2DOptions *>(obj);
22387       return ptr->UnPack(resolver);
22388     }
22389     case BuiltinOptions_ConcatEmbeddingsOptions:
22390     {
22391       auto ptr = reinterpret_cast<const circle::ConcatEmbeddingsOptions *>(obj);
22392       return ptr->UnPack(resolver);
22393     }
22394     case BuiltinOptions_LSHProjectionOptions:
22395     {
22396       auto ptr = reinterpret_cast<const circle::LSHProjectionOptions *>(obj);
22397       return ptr->UnPack(resolver);
22398     }
22399     case BuiltinOptions_Pool2DOptions:
22400     {
22401       auto ptr = reinterpret_cast<const circle::Pool2DOptions *>(obj);
22402       return ptr->UnPack(resolver);
22403     }
22404     case BuiltinOptions_SVDFOptions:
22405     {
22406       auto ptr = reinterpret_cast<const circle::SVDFOptions *>(obj);
22407       return ptr->UnPack(resolver);
22408     }
22409     case BuiltinOptions_RNNOptions:
22410     {
22411       auto ptr = reinterpret_cast<const circle::RNNOptions *>(obj);
22412       return ptr->UnPack(resolver);
22413     }
22414     case BuiltinOptions_FullyConnectedOptions:
22415     {
22416       auto ptr = reinterpret_cast<const circle::FullyConnectedOptions *>(obj);
22417       return ptr->UnPack(resolver);
22418     }
22419     case BuiltinOptions_SoftmaxOptions:
22420     {
22421       auto ptr = reinterpret_cast<const circle::SoftmaxOptions *>(obj);
22422       return ptr->UnPack(resolver);
22423     }
22424     case BuiltinOptions_ConcatenationOptions:
22425     {
22426       auto ptr = reinterpret_cast<const circle::ConcatenationOptions *>(obj);
22427       return ptr->UnPack(resolver);
22428     }
22429     case BuiltinOptions_AddOptions:
22430     {
22431       auto ptr = reinterpret_cast<const circle::AddOptions *>(obj);
22432       return ptr->UnPack(resolver);
22433     }
22434     case BuiltinOptions_L2NormOptions:
22435     {
22436       auto ptr = reinterpret_cast<const circle::L2NormOptions *>(obj);
22437       return ptr->UnPack(resolver);
22438     }
22439     case BuiltinOptions_LocalResponseNormalizationOptions:
22440     {
22441       auto ptr = reinterpret_cast<const circle::LocalResponseNormalizationOptions *>(obj);
22442       return ptr->UnPack(resolver);
22443     }
22444     case BuiltinOptions_LSTMOptions:
22445     {
22446       auto ptr = reinterpret_cast<const circle::LSTMOptions *>(obj);
22447       return ptr->UnPack(resolver);
22448     }
22449     case BuiltinOptions_ResizeBilinearOptions:
22450     {
22451       auto ptr = reinterpret_cast<const circle::ResizeBilinearOptions *>(obj);
22452       return ptr->UnPack(resolver);
22453     }
22454     case BuiltinOptions_CallOptions:
22455     {
22456       auto ptr = reinterpret_cast<const circle::CallOptions *>(obj);
22457       return ptr->UnPack(resolver);
22458     }
22459     case BuiltinOptions_ReshapeOptions:
22460     {
22461       auto ptr = reinterpret_cast<const circle::ReshapeOptions *>(obj);
22462       return ptr->UnPack(resolver);
22463     }
22464     case BuiltinOptions_SkipGramOptions:
22465     {
22466       auto ptr = reinterpret_cast<const circle::SkipGramOptions *>(obj);
22467       return ptr->UnPack(resolver);
22468     }
22469     case BuiltinOptions_SpaceToDepthOptions:
22470     {
22471       auto ptr = reinterpret_cast<const circle::SpaceToDepthOptions *>(obj);
22472       return ptr->UnPack(resolver);
22473     }
22474     case BuiltinOptions_EmbeddingLookupSparseOptions:
22475     {
22476       auto ptr = reinterpret_cast<const circle::EmbeddingLookupSparseOptions *>(obj);
22477       return ptr->UnPack(resolver);
22478     }
22479     case BuiltinOptions_MulOptions:
22480     {
22481       auto ptr = reinterpret_cast<const circle::MulOptions *>(obj);
22482       return ptr->UnPack(resolver);
22483     }
22484     case BuiltinOptions_PadOptions:
22485     {
22486       auto ptr = reinterpret_cast<const circle::PadOptions *>(obj);
22487       return ptr->UnPack(resolver);
22488     }
22489     case BuiltinOptions_GatherOptions:
22490     {
22491       auto ptr = reinterpret_cast<const circle::GatherOptions *>(obj);
22492       return ptr->UnPack(resolver);
22493     }
22494     case BuiltinOptions_BatchToSpaceNDOptions:
22495     {
22496       auto ptr = reinterpret_cast<const circle::BatchToSpaceNDOptions *>(obj);
22497       return ptr->UnPack(resolver);
22498     }
22499     case BuiltinOptions_SpaceToBatchNDOptions:
22500     {
22501       auto ptr = reinterpret_cast<const circle::SpaceToBatchNDOptions *>(obj);
22502       return ptr->UnPack(resolver);
22503     }
22504     case BuiltinOptions_TransposeOptions:
22505     {
22506       auto ptr = reinterpret_cast<const circle::TransposeOptions *>(obj);
22507       return ptr->UnPack(resolver);
22508     }
22509     case BuiltinOptions_ReducerOptions:
22510     {
22511       auto ptr = reinterpret_cast<const circle::ReducerOptions *>(obj);
22512       return ptr->UnPack(resolver);
22513     }
22514     case BuiltinOptions_SubOptions:
22515     {
22516       auto ptr = reinterpret_cast<const circle::SubOptions *>(obj);
22517       return ptr->UnPack(resolver);
22518     }
22519     case BuiltinOptions_DivOptions:
22520     {
22521       auto ptr = reinterpret_cast<const circle::DivOptions *>(obj);
22522       return ptr->UnPack(resolver);
22523     }
22524     case BuiltinOptions_SqueezeOptions:
22525     {
22526       auto ptr = reinterpret_cast<const circle::SqueezeOptions *>(obj);
22527       return ptr->UnPack(resolver);
22528     }
22529     case BuiltinOptions_SequenceRNNOptions:
22530     {
22531       auto ptr = reinterpret_cast<const circle::SequenceRNNOptions *>(obj);
22532       return ptr->UnPack(resolver);
22533     }
22534     case BuiltinOptions_StridedSliceOptions:
22535     {
22536       auto ptr = reinterpret_cast<const circle::StridedSliceOptions *>(obj);
22537       return ptr->UnPack(resolver);
22538     }
22539     case BuiltinOptions_ExpOptions:
22540     {
22541       auto ptr = reinterpret_cast<const circle::ExpOptions *>(obj);
22542       return ptr->UnPack(resolver);
22543     }
22544     case BuiltinOptions_TopKV2Options:
22545     {
22546       auto ptr = reinterpret_cast<const circle::TopKV2Options *>(obj);
22547       return ptr->UnPack(resolver);
22548     }
22549     case BuiltinOptions_SplitOptions:
22550     {
22551       auto ptr = reinterpret_cast<const circle::SplitOptions *>(obj);
22552       return ptr->UnPack(resolver);
22553     }
22554     case BuiltinOptions_LogSoftmaxOptions:
22555     {
22556       auto ptr = reinterpret_cast<const circle::LogSoftmaxOptions *>(obj);
22557       return ptr->UnPack(resolver);
22558     }
22559     case BuiltinOptions_CastOptions:
22560     {
22561       auto ptr = reinterpret_cast<const circle::CastOptions *>(obj);
22562       return ptr->UnPack(resolver);
22563     }
22564     case BuiltinOptions_DequantizeOptions:
22565     {
22566       auto ptr = reinterpret_cast<const circle::DequantizeOptions *>(obj);
22567       return ptr->UnPack(resolver);
22568     }
22569     case BuiltinOptions_MaximumMinimumOptions:
22570     {
22571       auto ptr = reinterpret_cast<const circle::MaximumMinimumOptions *>(obj);
22572       return ptr->UnPack(resolver);
22573     }
22574     case BuiltinOptions_ArgMaxOptions:
22575     {
22576       auto ptr = reinterpret_cast<const circle::ArgMaxOptions *>(obj);
22577       return ptr->UnPack(resolver);
22578     }
22579     case BuiltinOptions_LessOptions:
22580     {
22581       auto ptr = reinterpret_cast<const circle::LessOptions *>(obj);
22582       return ptr->UnPack(resolver);
22583     }
22584     case BuiltinOptions_NegOptions:
22585     {
22586       auto ptr = reinterpret_cast<const circle::NegOptions *>(obj);
22587       return ptr->UnPack(resolver);
22588     }
22589     case BuiltinOptions_PadV2Options:
22590     {
22591       auto ptr = reinterpret_cast<const circle::PadV2Options *>(obj);
22592       return ptr->UnPack(resolver);
22593     }
22594     case BuiltinOptions_GreaterOptions:
22595     {
22596       auto ptr = reinterpret_cast<const circle::GreaterOptions *>(obj);
22597       return ptr->UnPack(resolver);
22598     }
22599     case BuiltinOptions_GreaterEqualOptions:
22600     {
22601       auto ptr = reinterpret_cast<const circle::GreaterEqualOptions *>(obj);
22602       return ptr->UnPack(resolver);
22603     }
22604     case BuiltinOptions_LessEqualOptions:
22605     {
22606       auto ptr = reinterpret_cast<const circle::LessEqualOptions *>(obj);
22607       return ptr->UnPack(resolver);
22608     }
22609     case BuiltinOptions_SelectOptions:
22610     {
22611       auto ptr = reinterpret_cast<const circle::SelectOptions *>(obj);
22612       return ptr->UnPack(resolver);
22613     }
22614     case BuiltinOptions_SliceOptions:
22615     {
22616       auto ptr = reinterpret_cast<const circle::SliceOptions *>(obj);
22617       return ptr->UnPack(resolver);
22618     }
22619     case BuiltinOptions_TransposeConvOptions:
22620     {
22621       auto ptr = reinterpret_cast<const circle::TransposeConvOptions *>(obj);
22622       return ptr->UnPack(resolver);
22623     }
22624     case BuiltinOptions_SparseToDenseOptions:
22625     {
22626       auto ptr = reinterpret_cast<const circle::SparseToDenseOptions *>(obj);
22627       return ptr->UnPack(resolver);
22628     }
22629     case BuiltinOptions_TileOptions:
22630     {
22631       auto ptr = reinterpret_cast<const circle::TileOptions *>(obj);
22632       return ptr->UnPack(resolver);
22633     }
22634     case BuiltinOptions_ExpandDimsOptions:
22635     {
22636       auto ptr = reinterpret_cast<const circle::ExpandDimsOptions *>(obj);
22637       return ptr->UnPack(resolver);
22638     }
22639     case BuiltinOptions_EqualOptions:
22640     {
22641       auto ptr = reinterpret_cast<const circle::EqualOptions *>(obj);
22642       return ptr->UnPack(resolver);
22643     }
22644     case BuiltinOptions_NotEqualOptions:
22645     {
22646       auto ptr = reinterpret_cast<const circle::NotEqualOptions *>(obj);
22647       return ptr->UnPack(resolver);
22648     }
22649     case BuiltinOptions_ShapeOptions:
22650     {
22651       auto ptr = reinterpret_cast<const circle::ShapeOptions *>(obj);
22652       return ptr->UnPack(resolver);
22653     }
22654     case BuiltinOptions_PowOptions:
22655     {
22656       auto ptr = reinterpret_cast<const circle::PowOptions *>(obj);
22657       return ptr->UnPack(resolver);
22658     }
22659     case BuiltinOptions_ArgMinOptions:
22660     {
22661       auto ptr = reinterpret_cast<const circle::ArgMinOptions *>(obj);
22662       return ptr->UnPack(resolver);
22663     }
22664     case BuiltinOptions_FakeQuantOptions:
22665     {
22666       auto ptr = reinterpret_cast<const circle::FakeQuantOptions *>(obj);
22667       return ptr->UnPack(resolver);
22668     }
22669     case BuiltinOptions_PackOptions:
22670     {
22671       auto ptr = reinterpret_cast<const circle::PackOptions *>(obj);
22672       return ptr->UnPack(resolver);
22673     }
22674     case BuiltinOptions_LogicalOrOptions:
22675     {
22676       auto ptr = reinterpret_cast<const circle::LogicalOrOptions *>(obj);
22677       return ptr->UnPack(resolver);
22678     }
22679     case BuiltinOptions_OneHotOptions:
22680     {
22681       auto ptr = reinterpret_cast<const circle::OneHotOptions *>(obj);
22682       return ptr->UnPack(resolver);
22683     }
22684     case BuiltinOptions_LogicalAndOptions:
22685     {
22686       auto ptr = reinterpret_cast<const circle::LogicalAndOptions *>(obj);
22687       return ptr->UnPack(resolver);
22688     }
22689     case BuiltinOptions_LogicalNotOptions:
22690     {
22691       auto ptr = reinterpret_cast<const circle::LogicalNotOptions *>(obj);
22692       return ptr->UnPack(resolver);
22693     }
22694     case BuiltinOptions_UnpackOptions:
22695     {
22696       auto ptr = reinterpret_cast<const circle::UnpackOptions *>(obj);
22697       return ptr->UnPack(resolver);
22698     }
22699     case BuiltinOptions_FloorDivOptions:
22700     {
22701       auto ptr = reinterpret_cast<const circle::FloorDivOptions *>(obj);
22702       return ptr->UnPack(resolver);
22703     }
22704     case BuiltinOptions_SquareOptions:
22705     {
22706       auto ptr = reinterpret_cast<const circle::SquareOptions *>(obj);
22707       return ptr->UnPack(resolver);
22708     }
22709     case BuiltinOptions_ZerosLikeOptions:
22710     {
22711       auto ptr = reinterpret_cast<const circle::ZerosLikeOptions *>(obj);
22712       return ptr->UnPack(resolver);
22713     }
22714     case BuiltinOptions_FillOptions:
22715     {
22716       auto ptr = reinterpret_cast<const circle::FillOptions *>(obj);
22717       return ptr->UnPack(resolver);
22718     }
22719     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
22720     {
22721       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceLSTMOptions *>(obj);
22722       return ptr->UnPack(resolver);
22723     }
22724     case BuiltinOptions_BidirectionalSequenceRNNOptions:
22725     {
22726       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceRNNOptions *>(obj);
22727       return ptr->UnPack(resolver);
22728     }
22729     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
22730     {
22731       auto ptr = reinterpret_cast<const circle::UnidirectionalSequenceLSTMOptions *>(obj);
22732       return ptr->UnPack(resolver);
22733     }
22734     case BuiltinOptions_FloorModOptions:
22735     {
22736       auto ptr = reinterpret_cast<const circle::FloorModOptions *>(obj);
22737       return ptr->UnPack(resolver);
22738     }
22739     case BuiltinOptions_RangeOptions:
22740     {
22741       auto ptr = reinterpret_cast<const circle::RangeOptions *>(obj);
22742       return ptr->UnPack(resolver);
22743     }
22744     case BuiltinOptions_ResizeNearestNeighborOptions:
22745     {
22746       auto ptr = reinterpret_cast<const circle::ResizeNearestNeighborOptions *>(obj);
22747       return ptr->UnPack(resolver);
22748     }
22749     case BuiltinOptions_LeakyReluOptions:
22750     {
22751       auto ptr = reinterpret_cast<const circle::LeakyReluOptions *>(obj);
22752       return ptr->UnPack(resolver);
22753     }
22754     case BuiltinOptions_SquaredDifferenceOptions:
22755     {
22756       auto ptr = reinterpret_cast<const circle::SquaredDifferenceOptions *>(obj);
22757       return ptr->UnPack(resolver);
22758     }
22759     case BuiltinOptions_MirrorPadOptions:
22760     {
22761       auto ptr = reinterpret_cast<const circle::MirrorPadOptions *>(obj);
22762       return ptr->UnPack(resolver);
22763     }
22764     case BuiltinOptions_AbsOptions:
22765     {
22766       auto ptr = reinterpret_cast<const circle::AbsOptions *>(obj);
22767       return ptr->UnPack(resolver);
22768     }
22769     case BuiltinOptions_SplitVOptions:
22770     {
22771       auto ptr = reinterpret_cast<const circle::SplitVOptions *>(obj);
22772       return ptr->UnPack(resolver);
22773     }
22774     case BuiltinOptions_UniqueOptions:
22775     {
22776       auto ptr = reinterpret_cast<const circle::UniqueOptions *>(obj);
22777       return ptr->UnPack(resolver);
22778     }
22779     case BuiltinOptions_ReverseV2Options:
22780     {
22781       auto ptr = reinterpret_cast<const circle::ReverseV2Options *>(obj);
22782       return ptr->UnPack(resolver);
22783     }
22784     case BuiltinOptions_AddNOptions:
22785     {
22786       auto ptr = reinterpret_cast<const circle::AddNOptions *>(obj);
22787       return ptr->UnPack(resolver);
22788     }
22789     case BuiltinOptions_GatherNdOptions:
22790     {
22791       auto ptr = reinterpret_cast<const circle::GatherNdOptions *>(obj);
22792       return ptr->UnPack(resolver);
22793     }
22794     case BuiltinOptions_CosOptions:
22795     {
22796       auto ptr = reinterpret_cast<const circle::CosOptions *>(obj);
22797       return ptr->UnPack(resolver);
22798     }
22799     case BuiltinOptions_WhereOptions:
22800     {
22801       auto ptr = reinterpret_cast<const circle::WhereOptions *>(obj);
22802       return ptr->UnPack(resolver);
22803     }
22804     case BuiltinOptions_RankOptions:
22805     {
22806       auto ptr = reinterpret_cast<const circle::RankOptions *>(obj);
22807       return ptr->UnPack(resolver);
22808     }
22809     case BuiltinOptions_ReverseSequenceOptions:
22810     {
22811       auto ptr = reinterpret_cast<const circle::ReverseSequenceOptions *>(obj);
22812       return ptr->UnPack(resolver);
22813     }
22814     case BuiltinOptions_MatrixDiagOptions:
22815     {
22816       auto ptr = reinterpret_cast<const circle::MatrixDiagOptions *>(obj);
22817       return ptr->UnPack(resolver);
22818     }
22819     case BuiltinOptions_QuantizeOptions:
22820     {
22821       auto ptr = reinterpret_cast<const circle::QuantizeOptions *>(obj);
22822       return ptr->UnPack(resolver);
22823     }
22824     case BuiltinOptions_MatrixSetDiagOptions:
22825     {
22826       auto ptr = reinterpret_cast<const circle::MatrixSetDiagOptions *>(obj);
22827       return ptr->UnPack(resolver);
22828     }
22829     case BuiltinOptions_HardSwishOptions:
22830     {
22831       auto ptr = reinterpret_cast<const circle::HardSwishOptions *>(obj);
22832       return ptr->UnPack(resolver);
22833     }
22834     case BuiltinOptions_IfOptions:
22835     {
22836       auto ptr = reinterpret_cast<const circle::IfOptions *>(obj);
22837       return ptr->UnPack(resolver);
22838     }
22839     case BuiltinOptions_WhileOptions:
22840     {
22841       auto ptr = reinterpret_cast<const circle::WhileOptions *>(obj);
22842       return ptr->UnPack(resolver);
22843     }
22844     case BuiltinOptions_DepthToSpaceOptions:
22845     {
22846       auto ptr = reinterpret_cast<const circle::DepthToSpaceOptions *>(obj);
22847       return ptr->UnPack(resolver);
22848     }
22849     case BuiltinOptions_NonMaxSuppressionV4Options:
22850     {
22851       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV4Options *>(obj);
22852       return ptr->UnPack(resolver);
22853     }
22854     case BuiltinOptions_NonMaxSuppressionV5Options:
22855     {
22856       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV5Options *>(obj);
22857       return ptr->UnPack(resolver);
22858     }
22859     case BuiltinOptions_ScatterNdOptions:
22860     {
22861       auto ptr = reinterpret_cast<const circle::ScatterNdOptions *>(obj);
22862       return ptr->UnPack(resolver);
22863     }
22864     case BuiltinOptions_SelectV2Options:
22865     {
22866       auto ptr = reinterpret_cast<const circle::SelectV2Options *>(obj);
22867       return ptr->UnPack(resolver);
22868     }
22869     case BuiltinOptions_DensifyOptions:
22870     {
22871       auto ptr = reinterpret_cast<const circle::DensifyOptions *>(obj);
22872       return ptr->UnPack(resolver);
22873     }
22874     case BuiltinOptions_SegmentSumOptions:
22875     {
22876       auto ptr = reinterpret_cast<const circle::SegmentSumOptions *>(obj);
22877       return ptr->UnPack(resolver);
22878     }
22879     case BuiltinOptions_BatchMatMulOptions:
22880     {
22881       auto ptr = reinterpret_cast<const circle::BatchMatMulOptions *>(obj);
22882       return ptr->UnPack(resolver);
22883     }
22884     case BuiltinOptions_CumsumOptions:
22885     {
22886       auto ptr = reinterpret_cast<const circle::CumsumOptions *>(obj);
22887       return ptr->UnPack(resolver);
22888     }
22889     case BuiltinOptions_CallOnceOptions:
22890     {
22891       auto ptr = reinterpret_cast<const circle::CallOnceOptions *>(obj);
22892       return ptr->UnPack(resolver);
22893     }
22894     case BuiltinOptions_BroadcastToOptions:
22895     {
22896       auto ptr = reinterpret_cast<const circle::BroadcastToOptions *>(obj);
22897       return ptr->UnPack(resolver);
22898     }
22899     case BuiltinOptions_Rfft2dOptions:
22900     {
22901       auto ptr = reinterpret_cast<const circle::Rfft2dOptions *>(obj);
22902       return ptr->UnPack(resolver);
22903     }
22904     case BuiltinOptions_Conv3DOptions:
22905     {
22906       auto ptr = reinterpret_cast<const circle::Conv3DOptions *>(obj);
22907       return ptr->UnPack(resolver);
22908     }
22909     case BuiltinOptions_HashtableOptions:
22910     {
22911       auto ptr = reinterpret_cast<const circle::HashtableOptions *>(obj);
22912       return ptr->UnPack(resolver);
22913     }
22914     case BuiltinOptions_HashtableFindOptions:
22915     {
22916       auto ptr = reinterpret_cast<const circle::HashtableFindOptions *>(obj);
22917       return ptr->UnPack(resolver);
22918     }
22919     case BuiltinOptions_HashtableImportOptions:
22920     {
22921       auto ptr = reinterpret_cast<const circle::HashtableImportOptions *>(obj);
22922       return ptr->UnPack(resolver);
22923     }
22924     case BuiltinOptions_HashtableSizeOptions:
22925     {
22926       auto ptr = reinterpret_cast<const circle::HashtableSizeOptions *>(obj);
22927       return ptr->UnPack(resolver);
22928     }
22929     case BuiltinOptions_VarHandleOptions:
22930     {
22931       auto ptr = reinterpret_cast<const circle::VarHandleOptions *>(obj);
22932       return ptr->UnPack(resolver);
22933     }
22934     case BuiltinOptions_ReadVariableOptions:
22935     {
22936       auto ptr = reinterpret_cast<const circle::ReadVariableOptions *>(obj);
22937       return ptr->UnPack(resolver);
22938     }
22939     case BuiltinOptions_AssignVariableOptions:
22940     {
22941       auto ptr = reinterpret_cast<const circle::AssignVariableOptions *>(obj);
22942       return ptr->UnPack(resolver);
22943     }
22944     case BuiltinOptions_RandomOptions:
22945     {
22946       auto ptr = reinterpret_cast<const circle::RandomOptions *>(obj);
22947       return ptr->UnPack(resolver);
22948     }
22949     case BuiltinOptions_BCQGatherOptions:
22950     {
22951       auto ptr = reinterpret_cast<const circle::BCQGatherOptions *>(obj);
22952       return ptr->UnPack(resolver);
22953     }
22954     case BuiltinOptions_BCQFullyConnectedOptions:
22955     {
22956       auto ptr = reinterpret_cast<const circle::BCQFullyConnectedOptions *>(obj);
22957       return ptr->UnPack(resolver);
22958     }
22959     case BuiltinOptions_InstanceNormOptions:
22960     {
22961       auto ptr = reinterpret_cast<const circle::InstanceNormOptions *>(obj);
22962       return ptr->UnPack(resolver);
22963     }
22964     default:
22965       return nullptr;
22966   }
22967 }
22968
22969 inline flatbuffers::Offset<void>
22970 BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb,
22971                           const flatbuffers::rehasher_function_t *_rehasher) const
22972 {
22973   switch (type)
22974   {
22975     case BuiltinOptions_Conv2DOptions:
22976     {
22977       auto ptr = reinterpret_cast<const circle::Conv2DOptionsT *>(value);
22978       return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
22979     }
22980     case BuiltinOptions_DepthwiseConv2DOptions:
22981     {
22982       auto ptr = reinterpret_cast<const circle::DepthwiseConv2DOptionsT *>(value);
22983       return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
22984     }
22985     case BuiltinOptions_ConcatEmbeddingsOptions:
22986     {
22987       auto ptr = reinterpret_cast<const circle::ConcatEmbeddingsOptionsT *>(value);
22988       return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
22989     }
22990     case BuiltinOptions_LSHProjectionOptions:
22991     {
22992       auto ptr = reinterpret_cast<const circle::LSHProjectionOptionsT *>(value);
22993       return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
22994     }
22995     case BuiltinOptions_Pool2DOptions:
22996     {
22997       auto ptr = reinterpret_cast<const circle::Pool2DOptionsT *>(value);
22998       return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
22999     }
23000     case BuiltinOptions_SVDFOptions:
23001     {
23002       auto ptr = reinterpret_cast<const circle::SVDFOptionsT *>(value);
23003       return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
23004     }
23005     case BuiltinOptions_RNNOptions:
23006     {
23007       auto ptr = reinterpret_cast<const circle::RNNOptionsT *>(value);
23008       return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
23009     }
23010     case BuiltinOptions_FullyConnectedOptions:
23011     {
23012       auto ptr = reinterpret_cast<const circle::FullyConnectedOptionsT *>(value);
23013       return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
23014     }
23015     case BuiltinOptions_SoftmaxOptions:
23016     {
23017       auto ptr = reinterpret_cast<const circle::SoftmaxOptionsT *>(value);
23018       return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
23019     }
23020     case BuiltinOptions_ConcatenationOptions:
23021     {
23022       auto ptr = reinterpret_cast<const circle::ConcatenationOptionsT *>(value);
23023       return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
23024     }
23025     case BuiltinOptions_AddOptions:
23026     {
23027       auto ptr = reinterpret_cast<const circle::AddOptionsT *>(value);
23028       return CreateAddOptions(_fbb, ptr, _rehasher).Union();
23029     }
23030     case BuiltinOptions_L2NormOptions:
23031     {
23032       auto ptr = reinterpret_cast<const circle::L2NormOptionsT *>(value);
23033       return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
23034     }
23035     case BuiltinOptions_LocalResponseNormalizationOptions:
23036     {
23037       auto ptr = reinterpret_cast<const circle::LocalResponseNormalizationOptionsT *>(value);
23038       return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
23039     }
23040     case BuiltinOptions_LSTMOptions:
23041     {
23042       auto ptr = reinterpret_cast<const circle::LSTMOptionsT *>(value);
23043       return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
23044     }
23045     case BuiltinOptions_ResizeBilinearOptions:
23046     {
23047       auto ptr = reinterpret_cast<const circle::ResizeBilinearOptionsT *>(value);
23048       return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
23049     }
23050     case BuiltinOptions_CallOptions:
23051     {
23052       auto ptr = reinterpret_cast<const circle::CallOptionsT *>(value);
23053       return CreateCallOptions(_fbb, ptr, _rehasher).Union();
23054     }
23055     case BuiltinOptions_ReshapeOptions:
23056     {
23057       auto ptr = reinterpret_cast<const circle::ReshapeOptionsT *>(value);
23058       return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
23059     }
23060     case BuiltinOptions_SkipGramOptions:
23061     {
23062       auto ptr = reinterpret_cast<const circle::SkipGramOptionsT *>(value);
23063       return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
23064     }
23065     case BuiltinOptions_SpaceToDepthOptions:
23066     {
23067       auto ptr = reinterpret_cast<const circle::SpaceToDepthOptionsT *>(value);
23068       return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
23069     }
23070     case BuiltinOptions_EmbeddingLookupSparseOptions:
23071     {
23072       auto ptr = reinterpret_cast<const circle::EmbeddingLookupSparseOptionsT *>(value);
23073       return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
23074     }
23075     case BuiltinOptions_MulOptions:
23076     {
23077       auto ptr = reinterpret_cast<const circle::MulOptionsT *>(value);
23078       return CreateMulOptions(_fbb, ptr, _rehasher).Union();
23079     }
23080     case BuiltinOptions_PadOptions:
23081     {
23082       auto ptr = reinterpret_cast<const circle::PadOptionsT *>(value);
23083       return CreatePadOptions(_fbb, ptr, _rehasher).Union();
23084     }
23085     case BuiltinOptions_GatherOptions:
23086     {
23087       auto ptr = reinterpret_cast<const circle::GatherOptionsT *>(value);
23088       return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
23089     }
23090     case BuiltinOptions_BatchToSpaceNDOptions:
23091     {
23092       auto ptr = reinterpret_cast<const circle::BatchToSpaceNDOptionsT *>(value);
23093       return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
23094     }
23095     case BuiltinOptions_SpaceToBatchNDOptions:
23096     {
23097       auto ptr = reinterpret_cast<const circle::SpaceToBatchNDOptionsT *>(value);
23098       return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
23099     }
23100     case BuiltinOptions_TransposeOptions:
23101     {
23102       auto ptr = reinterpret_cast<const circle::TransposeOptionsT *>(value);
23103       return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
23104     }
23105     case BuiltinOptions_ReducerOptions:
23106     {
23107       auto ptr = reinterpret_cast<const circle::ReducerOptionsT *>(value);
23108       return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
23109     }
23110     case BuiltinOptions_SubOptions:
23111     {
23112       auto ptr = reinterpret_cast<const circle::SubOptionsT *>(value);
23113       return CreateSubOptions(_fbb, ptr, _rehasher).Union();
23114     }
23115     case BuiltinOptions_DivOptions:
23116     {
23117       auto ptr = reinterpret_cast<const circle::DivOptionsT *>(value);
23118       return CreateDivOptions(_fbb, ptr, _rehasher).Union();
23119     }
23120     case BuiltinOptions_SqueezeOptions:
23121     {
23122       auto ptr = reinterpret_cast<const circle::SqueezeOptionsT *>(value);
23123       return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
23124     }
23125     case BuiltinOptions_SequenceRNNOptions:
23126     {
23127       auto ptr = reinterpret_cast<const circle::SequenceRNNOptionsT *>(value);
23128       return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
23129     }
23130     case BuiltinOptions_StridedSliceOptions:
23131     {
23132       auto ptr = reinterpret_cast<const circle::StridedSliceOptionsT *>(value);
23133       return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
23134     }
23135     case BuiltinOptions_ExpOptions:
23136     {
23137       auto ptr = reinterpret_cast<const circle::ExpOptionsT *>(value);
23138       return CreateExpOptions(_fbb, ptr, _rehasher).Union();
23139     }
23140     case BuiltinOptions_TopKV2Options:
23141     {
23142       auto ptr = reinterpret_cast<const circle::TopKV2OptionsT *>(value);
23143       return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
23144     }
23145     case BuiltinOptions_SplitOptions:
23146     {
23147       auto ptr = reinterpret_cast<const circle::SplitOptionsT *>(value);
23148       return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
23149     }
23150     case BuiltinOptions_LogSoftmaxOptions:
23151     {
23152       auto ptr = reinterpret_cast<const circle::LogSoftmaxOptionsT *>(value);
23153       return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
23154     }
23155     case BuiltinOptions_CastOptions:
23156     {
23157       auto ptr = reinterpret_cast<const circle::CastOptionsT *>(value);
23158       return CreateCastOptions(_fbb, ptr, _rehasher).Union();
23159     }
23160     case BuiltinOptions_DequantizeOptions:
23161     {
23162       auto ptr = reinterpret_cast<const circle::DequantizeOptionsT *>(value);
23163       return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
23164     }
23165     case BuiltinOptions_MaximumMinimumOptions:
23166     {
23167       auto ptr = reinterpret_cast<const circle::MaximumMinimumOptionsT *>(value);
23168       return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
23169     }
23170     case BuiltinOptions_ArgMaxOptions:
23171     {
23172       auto ptr = reinterpret_cast<const circle::ArgMaxOptionsT *>(value);
23173       return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
23174     }
23175     case BuiltinOptions_LessOptions:
23176     {
23177       auto ptr = reinterpret_cast<const circle::LessOptionsT *>(value);
23178       return CreateLessOptions(_fbb, ptr, _rehasher).Union();
23179     }
23180     case BuiltinOptions_NegOptions:
23181     {
23182       auto ptr = reinterpret_cast<const circle::NegOptionsT *>(value);
23183       return CreateNegOptions(_fbb, ptr, _rehasher).Union();
23184     }
23185     case BuiltinOptions_PadV2Options:
23186     {
23187       auto ptr = reinterpret_cast<const circle::PadV2OptionsT *>(value);
23188       return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
23189     }
23190     case BuiltinOptions_GreaterOptions:
23191     {
23192       auto ptr = reinterpret_cast<const circle::GreaterOptionsT *>(value);
23193       return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
23194     }
23195     case BuiltinOptions_GreaterEqualOptions:
23196     {
23197       auto ptr = reinterpret_cast<const circle::GreaterEqualOptionsT *>(value);
23198       return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
23199     }
23200     case BuiltinOptions_LessEqualOptions:
23201     {
23202       auto ptr = reinterpret_cast<const circle::LessEqualOptionsT *>(value);
23203       return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
23204     }
23205     case BuiltinOptions_SelectOptions:
23206     {
23207       auto ptr = reinterpret_cast<const circle::SelectOptionsT *>(value);
23208       return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
23209     }
23210     case BuiltinOptions_SliceOptions:
23211     {
23212       auto ptr = reinterpret_cast<const circle::SliceOptionsT *>(value);
23213       return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
23214     }
23215     case BuiltinOptions_TransposeConvOptions:
23216     {
23217       auto ptr = reinterpret_cast<const circle::TransposeConvOptionsT *>(value);
23218       return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
23219     }
23220     case BuiltinOptions_SparseToDenseOptions:
23221     {
23222       auto ptr = reinterpret_cast<const circle::SparseToDenseOptionsT *>(value);
23223       return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
23224     }
23225     case BuiltinOptions_TileOptions:
23226     {
23227       auto ptr = reinterpret_cast<const circle::TileOptionsT *>(value);
23228       return CreateTileOptions(_fbb, ptr, _rehasher).Union();
23229     }
23230     case BuiltinOptions_ExpandDimsOptions:
23231     {
23232       auto ptr = reinterpret_cast<const circle::ExpandDimsOptionsT *>(value);
23233       return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
23234     }
23235     case BuiltinOptions_EqualOptions:
23236     {
23237       auto ptr = reinterpret_cast<const circle::EqualOptionsT *>(value);
23238       return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
23239     }
23240     case BuiltinOptions_NotEqualOptions:
23241     {
23242       auto ptr = reinterpret_cast<const circle::NotEqualOptionsT *>(value);
23243       return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
23244     }
23245     case BuiltinOptions_ShapeOptions:
23246     {
23247       auto ptr = reinterpret_cast<const circle::ShapeOptionsT *>(value);
23248       return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
23249     }
23250     case BuiltinOptions_PowOptions:
23251     {
23252       auto ptr = reinterpret_cast<const circle::PowOptionsT *>(value);
23253       return CreatePowOptions(_fbb, ptr, _rehasher).Union();
23254     }
23255     case BuiltinOptions_ArgMinOptions:
23256     {
23257       auto ptr = reinterpret_cast<const circle::ArgMinOptionsT *>(value);
23258       return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
23259     }
23260     case BuiltinOptions_FakeQuantOptions:
23261     {
23262       auto ptr = reinterpret_cast<const circle::FakeQuantOptionsT *>(value);
23263       return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
23264     }
23265     case BuiltinOptions_PackOptions:
23266     {
23267       auto ptr = reinterpret_cast<const circle::PackOptionsT *>(value);
23268       return CreatePackOptions(_fbb, ptr, _rehasher).Union();
23269     }
23270     case BuiltinOptions_LogicalOrOptions:
23271     {
23272       auto ptr = reinterpret_cast<const circle::LogicalOrOptionsT *>(value);
23273       return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
23274     }
23275     case BuiltinOptions_OneHotOptions:
23276     {
23277       auto ptr = reinterpret_cast<const circle::OneHotOptionsT *>(value);
23278       return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
23279     }
23280     case BuiltinOptions_LogicalAndOptions:
23281     {
23282       auto ptr = reinterpret_cast<const circle::LogicalAndOptionsT *>(value);
23283       return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
23284     }
23285     case BuiltinOptions_LogicalNotOptions:
23286     {
23287       auto ptr = reinterpret_cast<const circle::LogicalNotOptionsT *>(value);
23288       return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
23289     }
23290     case BuiltinOptions_UnpackOptions:
23291     {
23292       auto ptr = reinterpret_cast<const circle::UnpackOptionsT *>(value);
23293       return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
23294     }
23295     case BuiltinOptions_FloorDivOptions:
23296     {
23297       auto ptr = reinterpret_cast<const circle::FloorDivOptionsT *>(value);
23298       return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
23299     }
23300     case BuiltinOptions_SquareOptions:
23301     {
23302       auto ptr = reinterpret_cast<const circle::SquareOptionsT *>(value);
23303       return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
23304     }
23305     case BuiltinOptions_ZerosLikeOptions:
23306     {
23307       auto ptr = reinterpret_cast<const circle::ZerosLikeOptionsT *>(value);
23308       return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
23309     }
23310     case BuiltinOptions_FillOptions:
23311     {
23312       auto ptr = reinterpret_cast<const circle::FillOptionsT *>(value);
23313       return CreateFillOptions(_fbb, ptr, _rehasher).Union();
23314     }
23315     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
23316     {
23317       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceLSTMOptionsT *>(value);
23318       return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
23319     }
23320     case BuiltinOptions_BidirectionalSequenceRNNOptions:
23321     {
23322       auto ptr = reinterpret_cast<const circle::BidirectionalSequenceRNNOptionsT *>(value);
23323       return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
23324     }
23325     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
23326     {
23327       auto ptr = reinterpret_cast<const circle::UnidirectionalSequenceLSTMOptionsT *>(value);
23328       return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
23329     }
23330     case BuiltinOptions_FloorModOptions:
23331     {
23332       auto ptr = reinterpret_cast<const circle::FloorModOptionsT *>(value);
23333       return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
23334     }
23335     case BuiltinOptions_RangeOptions:
23336     {
23337       auto ptr = reinterpret_cast<const circle::RangeOptionsT *>(value);
23338       return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
23339     }
23340     case BuiltinOptions_ResizeNearestNeighborOptions:
23341     {
23342       auto ptr = reinterpret_cast<const circle::ResizeNearestNeighborOptionsT *>(value);
23343       return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
23344     }
23345     case BuiltinOptions_LeakyReluOptions:
23346     {
23347       auto ptr = reinterpret_cast<const circle::LeakyReluOptionsT *>(value);
23348       return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
23349     }
23350     case BuiltinOptions_SquaredDifferenceOptions:
23351     {
23352       auto ptr = reinterpret_cast<const circle::SquaredDifferenceOptionsT *>(value);
23353       return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
23354     }
23355     case BuiltinOptions_MirrorPadOptions:
23356     {
23357       auto ptr = reinterpret_cast<const circle::MirrorPadOptionsT *>(value);
23358       return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
23359     }
23360     case BuiltinOptions_AbsOptions:
23361     {
23362       auto ptr = reinterpret_cast<const circle::AbsOptionsT *>(value);
23363       return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
23364     }
23365     case BuiltinOptions_SplitVOptions:
23366     {
23367       auto ptr = reinterpret_cast<const circle::SplitVOptionsT *>(value);
23368       return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
23369     }
23370     case BuiltinOptions_UniqueOptions:
23371     {
23372       auto ptr = reinterpret_cast<const circle::UniqueOptionsT *>(value);
23373       return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
23374     }
23375     case BuiltinOptions_ReverseV2Options:
23376     {
23377       auto ptr = reinterpret_cast<const circle::ReverseV2OptionsT *>(value);
23378       return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
23379     }
23380     case BuiltinOptions_AddNOptions:
23381     {
23382       auto ptr = reinterpret_cast<const circle::AddNOptionsT *>(value);
23383       return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
23384     }
23385     case BuiltinOptions_GatherNdOptions:
23386     {
23387       auto ptr = reinterpret_cast<const circle::GatherNdOptionsT *>(value);
23388       return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
23389     }
23390     case BuiltinOptions_CosOptions:
23391     {
23392       auto ptr = reinterpret_cast<const circle::CosOptionsT *>(value);
23393       return CreateCosOptions(_fbb, ptr, _rehasher).Union();
23394     }
23395     case BuiltinOptions_WhereOptions:
23396     {
23397       auto ptr = reinterpret_cast<const circle::WhereOptionsT *>(value);
23398       return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
23399     }
23400     case BuiltinOptions_RankOptions:
23401     {
23402       auto ptr = reinterpret_cast<const circle::RankOptionsT *>(value);
23403       return CreateRankOptions(_fbb, ptr, _rehasher).Union();
23404     }
23405     case BuiltinOptions_ReverseSequenceOptions:
23406     {
23407       auto ptr = reinterpret_cast<const circle::ReverseSequenceOptionsT *>(value);
23408       return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
23409     }
23410     case BuiltinOptions_MatrixDiagOptions:
23411     {
23412       auto ptr = reinterpret_cast<const circle::MatrixDiagOptionsT *>(value);
23413       return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
23414     }
23415     case BuiltinOptions_QuantizeOptions:
23416     {
23417       auto ptr = reinterpret_cast<const circle::QuantizeOptionsT *>(value);
23418       return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
23419     }
23420     case BuiltinOptions_MatrixSetDiagOptions:
23421     {
23422       auto ptr = reinterpret_cast<const circle::MatrixSetDiagOptionsT *>(value);
23423       return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
23424     }
23425     case BuiltinOptions_HardSwishOptions:
23426     {
23427       auto ptr = reinterpret_cast<const circle::HardSwishOptionsT *>(value);
23428       return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
23429     }
23430     case BuiltinOptions_IfOptions:
23431     {
23432       auto ptr = reinterpret_cast<const circle::IfOptionsT *>(value);
23433       return CreateIfOptions(_fbb, ptr, _rehasher).Union();
23434     }
23435     case BuiltinOptions_WhileOptions:
23436     {
23437       auto ptr = reinterpret_cast<const circle::WhileOptionsT *>(value);
23438       return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
23439     }
23440     case BuiltinOptions_DepthToSpaceOptions:
23441     {
23442       auto ptr = reinterpret_cast<const circle::DepthToSpaceOptionsT *>(value);
23443       return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
23444     }
23445     case BuiltinOptions_NonMaxSuppressionV4Options:
23446     {
23447       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV4OptionsT *>(value);
23448       return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
23449     }
23450     case BuiltinOptions_NonMaxSuppressionV5Options:
23451     {
23452       auto ptr = reinterpret_cast<const circle::NonMaxSuppressionV5OptionsT *>(value);
23453       return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
23454     }
23455     case BuiltinOptions_ScatterNdOptions:
23456     {
23457       auto ptr = reinterpret_cast<const circle::ScatterNdOptionsT *>(value);
23458       return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
23459     }
23460     case BuiltinOptions_SelectV2Options:
23461     {
23462       auto ptr = reinterpret_cast<const circle::SelectV2OptionsT *>(value);
23463       return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
23464     }
23465     case BuiltinOptions_DensifyOptions:
23466     {
23467       auto ptr = reinterpret_cast<const circle::DensifyOptionsT *>(value);
23468       return CreateDensifyOptions(_fbb, ptr, _rehasher).Union();
23469     }
23470     case BuiltinOptions_SegmentSumOptions:
23471     {
23472       auto ptr = reinterpret_cast<const circle::SegmentSumOptionsT *>(value);
23473       return CreateSegmentSumOptions(_fbb, ptr, _rehasher).Union();
23474     }
23475     case BuiltinOptions_BatchMatMulOptions:
23476     {
23477       auto ptr = reinterpret_cast<const circle::BatchMatMulOptionsT *>(value);
23478       return CreateBatchMatMulOptions(_fbb, ptr, _rehasher).Union();
23479     }
23480     case BuiltinOptions_CumsumOptions:
23481     {
23482       auto ptr = reinterpret_cast<const circle::CumsumOptionsT *>(value);
23483       return CreateCumsumOptions(_fbb, ptr, _rehasher).Union();
23484     }
23485     case BuiltinOptions_CallOnceOptions:
23486     {
23487       auto ptr = reinterpret_cast<const circle::CallOnceOptionsT *>(value);
23488       return CreateCallOnceOptions(_fbb, ptr, _rehasher).Union();
23489     }
23490     case BuiltinOptions_BroadcastToOptions:
23491     {
23492       auto ptr = reinterpret_cast<const circle::BroadcastToOptionsT *>(value);
23493       return CreateBroadcastToOptions(_fbb, ptr, _rehasher).Union();
23494     }
23495     case BuiltinOptions_Rfft2dOptions:
23496     {
23497       auto ptr = reinterpret_cast<const circle::Rfft2dOptionsT *>(value);
23498       return CreateRfft2dOptions(_fbb, ptr, _rehasher).Union();
23499     }
23500     case BuiltinOptions_Conv3DOptions:
23501     {
23502       auto ptr = reinterpret_cast<const circle::Conv3DOptionsT *>(value);
23503       return CreateConv3DOptions(_fbb, ptr, _rehasher).Union();
23504     }
23505     case BuiltinOptions_HashtableOptions:
23506     {
23507       auto ptr = reinterpret_cast<const circle::HashtableOptionsT *>(value);
23508       return CreateHashtableOptions(_fbb, ptr, _rehasher).Union();
23509     }
23510     case BuiltinOptions_HashtableFindOptions:
23511     {
23512       auto ptr = reinterpret_cast<const circle::HashtableFindOptionsT *>(value);
23513       return CreateHashtableFindOptions(_fbb, ptr, _rehasher).Union();
23514     }
23515     case BuiltinOptions_HashtableImportOptions:
23516     {
23517       auto ptr = reinterpret_cast<const circle::HashtableImportOptionsT *>(value);
23518       return CreateHashtableImportOptions(_fbb, ptr, _rehasher).Union();
23519     }
23520     case BuiltinOptions_HashtableSizeOptions:
23521     {
23522       auto ptr = reinterpret_cast<const circle::HashtableSizeOptionsT *>(value);
23523       return CreateHashtableSizeOptions(_fbb, ptr, _rehasher).Union();
23524     }
23525     case BuiltinOptions_VarHandleOptions:
23526     {
23527       auto ptr = reinterpret_cast<const circle::VarHandleOptionsT *>(value);
23528       return CreateVarHandleOptions(_fbb, ptr, _rehasher).Union();
23529     }
23530     case BuiltinOptions_ReadVariableOptions:
23531     {
23532       auto ptr = reinterpret_cast<const circle::ReadVariableOptionsT *>(value);
23533       return CreateReadVariableOptions(_fbb, ptr, _rehasher).Union();
23534     }
23535     case BuiltinOptions_AssignVariableOptions:
23536     {
23537       auto ptr = reinterpret_cast<const circle::AssignVariableOptionsT *>(value);
23538       return CreateAssignVariableOptions(_fbb, ptr, _rehasher).Union();
23539     }
23540     case BuiltinOptions_RandomOptions:
23541     {
23542       auto ptr = reinterpret_cast<const circle::RandomOptionsT *>(value);
23543       return CreateRandomOptions(_fbb, ptr, _rehasher).Union();
23544     }
23545     case BuiltinOptions_BCQGatherOptions:
23546     {
23547       auto ptr = reinterpret_cast<const circle::BCQGatherOptionsT *>(value);
23548       return CreateBCQGatherOptions(_fbb, ptr, _rehasher).Union();
23549     }
23550     case BuiltinOptions_BCQFullyConnectedOptions:
23551     {
23552       auto ptr = reinterpret_cast<const circle::BCQFullyConnectedOptionsT *>(value);
23553       return CreateBCQFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
23554     }
23555     case BuiltinOptions_InstanceNormOptions:
23556     {
23557       auto ptr = reinterpret_cast<const circle::InstanceNormOptionsT *>(value);
23558       return CreateInstanceNormOptions(_fbb, ptr, _rehasher).Union();
23559     }
23560     default:
23561       return 0;
23562   }
23563 }
23564
23565 inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u)
23566   : type(u.type), value(nullptr)
23567 {
23568   switch (type)
23569   {
23570     case BuiltinOptions_Conv2DOptions:
23571     {
23572       value = new circle::Conv2DOptionsT(*reinterpret_cast<circle::Conv2DOptionsT *>(u.value));
23573       break;
23574     }
23575     case BuiltinOptions_DepthwiseConv2DOptions:
23576     {
23577       value = new circle::DepthwiseConv2DOptionsT(
23578         *reinterpret_cast<circle::DepthwiseConv2DOptionsT *>(u.value));
23579       break;
23580     }
23581     case BuiltinOptions_ConcatEmbeddingsOptions:
23582     {
23583       value = new circle::ConcatEmbeddingsOptionsT(
23584         *reinterpret_cast<circle::ConcatEmbeddingsOptionsT *>(u.value));
23585       break;
23586     }
23587     case BuiltinOptions_LSHProjectionOptions:
23588     {
23589       value = new circle::LSHProjectionOptionsT(
23590         *reinterpret_cast<circle::LSHProjectionOptionsT *>(u.value));
23591       break;
23592     }
23593     case BuiltinOptions_Pool2DOptions:
23594     {
23595       value = new circle::Pool2DOptionsT(*reinterpret_cast<circle::Pool2DOptionsT *>(u.value));
23596       break;
23597     }
23598     case BuiltinOptions_SVDFOptions:
23599     {
23600       value = new circle::SVDFOptionsT(*reinterpret_cast<circle::SVDFOptionsT *>(u.value));
23601       break;
23602     }
23603     case BuiltinOptions_RNNOptions:
23604     {
23605       value = new circle::RNNOptionsT(*reinterpret_cast<circle::RNNOptionsT *>(u.value));
23606       break;
23607     }
23608     case BuiltinOptions_FullyConnectedOptions:
23609     {
23610       value = new circle::FullyConnectedOptionsT(
23611         *reinterpret_cast<circle::FullyConnectedOptionsT *>(u.value));
23612       break;
23613     }
23614     case BuiltinOptions_SoftmaxOptions:
23615     {
23616       value = new circle::SoftmaxOptionsT(*reinterpret_cast<circle::SoftmaxOptionsT *>(u.value));
23617       break;
23618     }
23619     case BuiltinOptions_ConcatenationOptions:
23620     {
23621       value = new circle::ConcatenationOptionsT(
23622         *reinterpret_cast<circle::ConcatenationOptionsT *>(u.value));
23623       break;
23624     }
23625     case BuiltinOptions_AddOptions:
23626     {
23627       value = new circle::AddOptionsT(*reinterpret_cast<circle::AddOptionsT *>(u.value));
23628       break;
23629     }
23630     case BuiltinOptions_L2NormOptions:
23631     {
23632       value = new circle::L2NormOptionsT(*reinterpret_cast<circle::L2NormOptionsT *>(u.value));
23633       break;
23634     }
23635     case BuiltinOptions_LocalResponseNormalizationOptions:
23636     {
23637       value = new circle::LocalResponseNormalizationOptionsT(
23638         *reinterpret_cast<circle::LocalResponseNormalizationOptionsT *>(u.value));
23639       break;
23640     }
23641     case BuiltinOptions_LSTMOptions:
23642     {
23643       value = new circle::LSTMOptionsT(*reinterpret_cast<circle::LSTMOptionsT *>(u.value));
23644       break;
23645     }
23646     case BuiltinOptions_ResizeBilinearOptions:
23647     {
23648       value = new circle::ResizeBilinearOptionsT(
23649         *reinterpret_cast<circle::ResizeBilinearOptionsT *>(u.value));
23650       break;
23651     }
23652     case BuiltinOptions_CallOptions:
23653     {
23654       value = new circle::CallOptionsT(*reinterpret_cast<circle::CallOptionsT *>(u.value));
23655       break;
23656     }
23657     case BuiltinOptions_ReshapeOptions:
23658     {
23659       value = new circle::ReshapeOptionsT(*reinterpret_cast<circle::ReshapeOptionsT *>(u.value));
23660       break;
23661     }
23662     case BuiltinOptions_SkipGramOptions:
23663     {
23664       value = new circle::SkipGramOptionsT(*reinterpret_cast<circle::SkipGramOptionsT *>(u.value));
23665       break;
23666     }
23667     case BuiltinOptions_SpaceToDepthOptions:
23668     {
23669       value = new circle::SpaceToDepthOptionsT(
23670         *reinterpret_cast<circle::SpaceToDepthOptionsT *>(u.value));
23671       break;
23672     }
23673     case BuiltinOptions_EmbeddingLookupSparseOptions:
23674     {
23675       value = new circle::EmbeddingLookupSparseOptionsT(
23676         *reinterpret_cast<circle::EmbeddingLookupSparseOptionsT *>(u.value));
23677       break;
23678     }
23679     case BuiltinOptions_MulOptions:
23680     {
23681       value = new circle::MulOptionsT(*reinterpret_cast<circle::MulOptionsT *>(u.value));
23682       break;
23683     }
23684     case BuiltinOptions_PadOptions:
23685     {
23686       value = new circle::PadOptionsT(*reinterpret_cast<circle::PadOptionsT *>(u.value));
23687       break;
23688     }
23689     case BuiltinOptions_GatherOptions:
23690     {
23691       value = new circle::GatherOptionsT(*reinterpret_cast<circle::GatherOptionsT *>(u.value));
23692       break;
23693     }
23694     case BuiltinOptions_BatchToSpaceNDOptions:
23695     {
23696       value = new circle::BatchToSpaceNDOptionsT(
23697         *reinterpret_cast<circle::BatchToSpaceNDOptionsT *>(u.value));
23698       break;
23699     }
23700     case BuiltinOptions_SpaceToBatchNDOptions:
23701     {
23702       value = new circle::SpaceToBatchNDOptionsT(
23703         *reinterpret_cast<circle::SpaceToBatchNDOptionsT *>(u.value));
23704       break;
23705     }
23706     case BuiltinOptions_TransposeOptions:
23707     {
23708       value =
23709         new circle::TransposeOptionsT(*reinterpret_cast<circle::TransposeOptionsT *>(u.value));
23710       break;
23711     }
23712     case BuiltinOptions_ReducerOptions:
23713     {
23714       value = new circle::ReducerOptionsT(*reinterpret_cast<circle::ReducerOptionsT *>(u.value));
23715       break;
23716     }
23717     case BuiltinOptions_SubOptions:
23718     {
23719       value = new circle::SubOptionsT(*reinterpret_cast<circle::SubOptionsT *>(u.value));
23720       break;
23721     }
23722     case BuiltinOptions_DivOptions:
23723     {
23724       value = new circle::DivOptionsT(*reinterpret_cast<circle::DivOptionsT *>(u.value));
23725       break;
23726     }
23727     case BuiltinOptions_SqueezeOptions:
23728     {
23729       value = new circle::SqueezeOptionsT(*reinterpret_cast<circle::SqueezeOptionsT *>(u.value));
23730       break;
23731     }
23732     case BuiltinOptions_SequenceRNNOptions:
23733     {
23734       value =
23735         new circle::SequenceRNNOptionsT(*reinterpret_cast<circle::SequenceRNNOptionsT *>(u.value));
23736       break;
23737     }
23738     case BuiltinOptions_StridedSliceOptions:
23739     {
23740       value = new circle::StridedSliceOptionsT(
23741         *reinterpret_cast<circle::StridedSliceOptionsT *>(u.value));
23742       break;
23743     }
23744     case BuiltinOptions_ExpOptions:
23745     {
23746       value = new circle::ExpOptionsT(*reinterpret_cast<circle::ExpOptionsT *>(u.value));
23747       break;
23748     }
23749     case BuiltinOptions_TopKV2Options:
23750     {
23751       value = new circle::TopKV2OptionsT(*reinterpret_cast<circle::TopKV2OptionsT *>(u.value));
23752       break;
23753     }
23754     case BuiltinOptions_SplitOptions:
23755     {
23756       value = new circle::SplitOptionsT(*reinterpret_cast<circle::SplitOptionsT *>(u.value));
23757       break;
23758     }
23759     case BuiltinOptions_LogSoftmaxOptions:
23760     {
23761       value =
23762         new circle::LogSoftmaxOptionsT(*reinterpret_cast<circle::LogSoftmaxOptionsT *>(u.value));
23763       break;
23764     }
23765     case BuiltinOptions_CastOptions:
23766     {
23767       value = new circle::CastOptionsT(*reinterpret_cast<circle::CastOptionsT *>(u.value));
23768       break;
23769     }
23770     case BuiltinOptions_DequantizeOptions:
23771     {
23772       value =
23773         new circle::DequantizeOptionsT(*reinterpret_cast<circle::DequantizeOptionsT *>(u.value));
23774       break;
23775     }
23776     case BuiltinOptions_MaximumMinimumOptions:
23777     {
23778       value = new circle::MaximumMinimumOptionsT(
23779         *reinterpret_cast<circle::MaximumMinimumOptionsT *>(u.value));
23780       break;
23781     }
23782     case BuiltinOptions_ArgMaxOptions:
23783     {
23784       value = new circle::ArgMaxOptionsT(*reinterpret_cast<circle::ArgMaxOptionsT *>(u.value));
23785       break;
23786     }
23787     case BuiltinOptions_LessOptions:
23788     {
23789       value = new circle::LessOptionsT(*reinterpret_cast<circle::LessOptionsT *>(u.value));
23790       break;
23791     }
23792     case BuiltinOptions_NegOptions:
23793     {
23794       value = new circle::NegOptionsT(*reinterpret_cast<circle::NegOptionsT *>(u.value));
23795       break;
23796     }
23797     case BuiltinOptions_PadV2Options:
23798     {
23799       value = new circle::PadV2OptionsT(*reinterpret_cast<circle::PadV2OptionsT *>(u.value));
23800       break;
23801     }
23802     case BuiltinOptions_GreaterOptions:
23803     {
23804       value = new circle::GreaterOptionsT(*reinterpret_cast<circle::GreaterOptionsT *>(u.value));
23805       break;
23806     }
23807     case BuiltinOptions_GreaterEqualOptions:
23808     {
23809       value = new circle::GreaterEqualOptionsT(
23810         *reinterpret_cast<circle::GreaterEqualOptionsT *>(u.value));
23811       break;
23812     }
23813     case BuiltinOptions_LessEqualOptions:
23814     {
23815       value =
23816         new circle::LessEqualOptionsT(*reinterpret_cast<circle::LessEqualOptionsT *>(u.value));
23817       break;
23818     }
23819     case BuiltinOptions_SelectOptions:
23820     {
23821       value = new circle::SelectOptionsT(*reinterpret_cast<circle::SelectOptionsT *>(u.value));
23822       break;
23823     }
23824     case BuiltinOptions_SliceOptions:
23825     {
23826       value = new circle::SliceOptionsT(*reinterpret_cast<circle::SliceOptionsT *>(u.value));
23827       break;
23828     }
23829     case BuiltinOptions_TransposeConvOptions:
23830     {
23831       value = new circle::TransposeConvOptionsT(
23832         *reinterpret_cast<circle::TransposeConvOptionsT *>(u.value));
23833       break;
23834     }
23835     case BuiltinOptions_SparseToDenseOptions:
23836     {
23837       value = new circle::SparseToDenseOptionsT(
23838         *reinterpret_cast<circle::SparseToDenseOptionsT *>(u.value));
23839       break;
23840     }
23841     case BuiltinOptions_TileOptions:
23842     {
23843       value = new circle::TileOptionsT(*reinterpret_cast<circle::TileOptionsT *>(u.value));
23844       break;
23845     }
23846     case BuiltinOptions_ExpandDimsOptions:
23847     {
23848       value =
23849         new circle::ExpandDimsOptionsT(*reinterpret_cast<circle::ExpandDimsOptionsT *>(u.value));
23850       break;
23851     }
23852     case BuiltinOptions_EqualOptions:
23853     {
23854       value = new circle::EqualOptionsT(*reinterpret_cast<circle::EqualOptionsT *>(u.value));
23855       break;
23856     }
23857     case BuiltinOptions_NotEqualOptions:
23858     {
23859       value = new circle::NotEqualOptionsT(*reinterpret_cast<circle::NotEqualOptionsT *>(u.value));
23860       break;
23861     }
23862     case BuiltinOptions_ShapeOptions:
23863     {
23864       value = new circle::ShapeOptionsT(*reinterpret_cast<circle::ShapeOptionsT *>(u.value));
23865       break;
23866     }
23867     case BuiltinOptions_PowOptions:
23868     {
23869       value = new circle::PowOptionsT(*reinterpret_cast<circle::PowOptionsT *>(u.value));
23870       break;
23871     }
23872     case BuiltinOptions_ArgMinOptions:
23873     {
23874       value = new circle::ArgMinOptionsT(*reinterpret_cast<circle::ArgMinOptionsT *>(u.value));
23875       break;
23876     }
23877     case BuiltinOptions_FakeQuantOptions:
23878     {
23879       value =
23880         new circle::FakeQuantOptionsT(*reinterpret_cast<circle::FakeQuantOptionsT *>(u.value));
23881       break;
23882     }
23883     case BuiltinOptions_PackOptions:
23884     {
23885       value = new circle::PackOptionsT(*reinterpret_cast<circle::PackOptionsT *>(u.value));
23886       break;
23887     }
23888     case BuiltinOptions_LogicalOrOptions:
23889     {
23890       value =
23891         new circle::LogicalOrOptionsT(*reinterpret_cast<circle::LogicalOrOptionsT *>(u.value));
23892       break;
23893     }
23894     case BuiltinOptions_OneHotOptions:
23895     {
23896       value = new circle::OneHotOptionsT(*reinterpret_cast<circle::OneHotOptionsT *>(u.value));
23897       break;
23898     }
23899     case BuiltinOptions_LogicalAndOptions:
23900     {
23901       value =
23902         new circle::LogicalAndOptionsT(*reinterpret_cast<circle::LogicalAndOptionsT *>(u.value));
23903       break;
23904     }
23905     case BuiltinOptions_LogicalNotOptions:
23906     {
23907       value =
23908         new circle::LogicalNotOptionsT(*reinterpret_cast<circle::LogicalNotOptionsT *>(u.value));
23909       break;
23910     }
23911     case BuiltinOptions_UnpackOptions:
23912     {
23913       value = new circle::UnpackOptionsT(*reinterpret_cast<circle::UnpackOptionsT *>(u.value));
23914       break;
23915     }
23916     case BuiltinOptions_FloorDivOptions:
23917     {
23918       value = new circle::FloorDivOptionsT(*reinterpret_cast<circle::FloorDivOptionsT *>(u.value));
23919       break;
23920     }
23921     case BuiltinOptions_SquareOptions:
23922     {
23923       value = new circle::SquareOptionsT(*reinterpret_cast<circle::SquareOptionsT *>(u.value));
23924       break;
23925     }
23926     case BuiltinOptions_ZerosLikeOptions:
23927     {
23928       value =
23929         new circle::ZerosLikeOptionsT(*reinterpret_cast<circle::ZerosLikeOptionsT *>(u.value));
23930       break;
23931     }
23932     case BuiltinOptions_FillOptions:
23933     {
23934       value = new circle::FillOptionsT(*reinterpret_cast<circle::FillOptionsT *>(u.value));
23935       break;
23936     }
23937     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
23938     {
23939       value = new circle::BidirectionalSequenceLSTMOptionsT(
23940         *reinterpret_cast<circle::BidirectionalSequenceLSTMOptionsT *>(u.value));
23941       break;
23942     }
23943     case BuiltinOptions_BidirectionalSequenceRNNOptions:
23944     {
23945       value = new circle::BidirectionalSequenceRNNOptionsT(
23946         *reinterpret_cast<circle::BidirectionalSequenceRNNOptionsT *>(u.value));
23947       break;
23948     }
23949     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
23950     {
23951       value = new circle::UnidirectionalSequenceLSTMOptionsT(
23952         *reinterpret_cast<circle::UnidirectionalSequenceLSTMOptionsT *>(u.value));
23953       break;
23954     }
23955     case BuiltinOptions_FloorModOptions:
23956     {
23957       value = new circle::FloorModOptionsT(*reinterpret_cast<circle::FloorModOptionsT *>(u.value));
23958       break;
23959     }
23960     case BuiltinOptions_RangeOptions:
23961     {
23962       value = new circle::RangeOptionsT(*reinterpret_cast<circle::RangeOptionsT *>(u.value));
23963       break;
23964     }
23965     case BuiltinOptions_ResizeNearestNeighborOptions:
23966     {
23967       value = new circle::ResizeNearestNeighborOptionsT(
23968         *reinterpret_cast<circle::ResizeNearestNeighborOptionsT *>(u.value));
23969       break;
23970     }
23971     case BuiltinOptions_LeakyReluOptions:
23972     {
23973       value =
23974         new circle::LeakyReluOptionsT(*reinterpret_cast<circle::LeakyReluOptionsT *>(u.value));
23975       break;
23976     }
23977     case BuiltinOptions_SquaredDifferenceOptions:
23978     {
23979       value = new circle::SquaredDifferenceOptionsT(
23980         *reinterpret_cast<circle::SquaredDifferenceOptionsT *>(u.value));
23981       break;
23982     }
23983     case BuiltinOptions_MirrorPadOptions:
23984     {
23985       value =
23986         new circle::MirrorPadOptionsT(*reinterpret_cast<circle::MirrorPadOptionsT *>(u.value));
23987       break;
23988     }
23989     case BuiltinOptions_AbsOptions:
23990     {
23991       value = new circle::AbsOptionsT(*reinterpret_cast<circle::AbsOptionsT *>(u.value));
23992       break;
23993     }
23994     case BuiltinOptions_SplitVOptions:
23995     {
23996       value = new circle::SplitVOptionsT(*reinterpret_cast<circle::SplitVOptionsT *>(u.value));
23997       break;
23998     }
23999     case BuiltinOptions_UniqueOptions:
24000     {
24001       value = new circle::UniqueOptionsT(*reinterpret_cast<circle::UniqueOptionsT *>(u.value));
24002       break;
24003     }
24004     case BuiltinOptions_ReverseV2Options:
24005     {
24006       value =
24007         new circle::ReverseV2OptionsT(*reinterpret_cast<circle::ReverseV2OptionsT *>(u.value));
24008       break;
24009     }
24010     case BuiltinOptions_AddNOptions:
24011     {
24012       value = new circle::AddNOptionsT(*reinterpret_cast<circle::AddNOptionsT *>(u.value));
24013       break;
24014     }
24015     case BuiltinOptions_GatherNdOptions:
24016     {
24017       value = new circle::GatherNdOptionsT(*reinterpret_cast<circle::GatherNdOptionsT *>(u.value));
24018       break;
24019     }
24020     case BuiltinOptions_CosOptions:
24021     {
24022       value = new circle::CosOptionsT(*reinterpret_cast<circle::CosOptionsT *>(u.value));
24023       break;
24024     }
24025     case BuiltinOptions_WhereOptions:
24026     {
24027       value = new circle::WhereOptionsT(*reinterpret_cast<circle::WhereOptionsT *>(u.value));
24028       break;
24029     }
24030     case BuiltinOptions_RankOptions:
24031     {
24032       value = new circle::RankOptionsT(*reinterpret_cast<circle::RankOptionsT *>(u.value));
24033       break;
24034     }
24035     case BuiltinOptions_ReverseSequenceOptions:
24036     {
24037       value = new circle::ReverseSequenceOptionsT(
24038         *reinterpret_cast<circle::ReverseSequenceOptionsT *>(u.value));
24039       break;
24040     }
24041     case BuiltinOptions_MatrixDiagOptions:
24042     {
24043       value =
24044         new circle::MatrixDiagOptionsT(*reinterpret_cast<circle::MatrixDiagOptionsT *>(u.value));
24045       break;
24046     }
24047     case BuiltinOptions_QuantizeOptions:
24048     {
24049       value = new circle::QuantizeOptionsT(*reinterpret_cast<circle::QuantizeOptionsT *>(u.value));
24050       break;
24051     }
24052     case BuiltinOptions_MatrixSetDiagOptions:
24053     {
24054       value = new circle::MatrixSetDiagOptionsT(
24055         *reinterpret_cast<circle::MatrixSetDiagOptionsT *>(u.value));
24056       break;
24057     }
24058     case BuiltinOptions_HardSwishOptions:
24059     {
24060       value =
24061         new circle::HardSwishOptionsT(*reinterpret_cast<circle::HardSwishOptionsT *>(u.value));
24062       break;
24063     }
24064     case BuiltinOptions_IfOptions:
24065     {
24066       value = new circle::IfOptionsT(*reinterpret_cast<circle::IfOptionsT *>(u.value));
24067       break;
24068     }
24069     case BuiltinOptions_WhileOptions:
24070     {
24071       value = new circle::WhileOptionsT(*reinterpret_cast<circle::WhileOptionsT *>(u.value));
24072       break;
24073     }
24074     case BuiltinOptions_DepthToSpaceOptions:
24075     {
24076       value = new circle::DepthToSpaceOptionsT(
24077         *reinterpret_cast<circle::DepthToSpaceOptionsT *>(u.value));
24078       break;
24079     }
24080     case BuiltinOptions_NonMaxSuppressionV4Options:
24081     {
24082       value = new circle::NonMaxSuppressionV4OptionsT(
24083         *reinterpret_cast<circle::NonMaxSuppressionV4OptionsT *>(u.value));
24084       break;
24085     }
24086     case BuiltinOptions_NonMaxSuppressionV5Options:
24087     {
24088       value = new circle::NonMaxSuppressionV5OptionsT(
24089         *reinterpret_cast<circle::NonMaxSuppressionV5OptionsT *>(u.value));
24090       break;
24091     }
24092     case BuiltinOptions_ScatterNdOptions:
24093     {
24094       value =
24095         new circle::ScatterNdOptionsT(*reinterpret_cast<circle::ScatterNdOptionsT *>(u.value));
24096       break;
24097     }
24098     case BuiltinOptions_SelectV2Options:
24099     {
24100       value = new circle::SelectV2OptionsT(*reinterpret_cast<circle::SelectV2OptionsT *>(u.value));
24101       break;
24102     }
24103     case BuiltinOptions_DensifyOptions:
24104     {
24105       value = new circle::DensifyOptionsT(*reinterpret_cast<circle::DensifyOptionsT *>(u.value));
24106       break;
24107     }
24108     case BuiltinOptions_SegmentSumOptions:
24109     {
24110       value =
24111         new circle::SegmentSumOptionsT(*reinterpret_cast<circle::SegmentSumOptionsT *>(u.value));
24112       break;
24113     }
24114     case BuiltinOptions_BatchMatMulOptions:
24115     {
24116       value =
24117         new circle::BatchMatMulOptionsT(*reinterpret_cast<circle::BatchMatMulOptionsT *>(u.value));
24118       break;
24119     }
24120     case BuiltinOptions_CumsumOptions:
24121     {
24122       value = new circle::CumsumOptionsT(*reinterpret_cast<circle::CumsumOptionsT *>(u.value));
24123       break;
24124     }
24125     case BuiltinOptions_CallOnceOptions:
24126     {
24127       value = new circle::CallOnceOptionsT(*reinterpret_cast<circle::CallOnceOptionsT *>(u.value));
24128       break;
24129     }
24130     case BuiltinOptions_BroadcastToOptions:
24131     {
24132       value =
24133         new circle::BroadcastToOptionsT(*reinterpret_cast<circle::BroadcastToOptionsT *>(u.value));
24134       break;
24135     }
24136     case BuiltinOptions_Rfft2dOptions:
24137     {
24138       value = new circle::Rfft2dOptionsT(*reinterpret_cast<circle::Rfft2dOptionsT *>(u.value));
24139       break;
24140     }
24141     case BuiltinOptions_Conv3DOptions:
24142     {
24143       value = new circle::Conv3DOptionsT(*reinterpret_cast<circle::Conv3DOptionsT *>(u.value));
24144       break;
24145     }
24146     case BuiltinOptions_HashtableOptions:
24147     {
24148       value =
24149         new circle::HashtableOptionsT(*reinterpret_cast<circle::HashtableOptionsT *>(u.value));
24150       break;
24151     }
24152     case BuiltinOptions_HashtableFindOptions:
24153     {
24154       value = new circle::HashtableFindOptionsT(
24155         *reinterpret_cast<circle::HashtableFindOptionsT *>(u.value));
24156       break;
24157     }
24158     case BuiltinOptions_HashtableImportOptions:
24159     {
24160       value = new circle::HashtableImportOptionsT(
24161         *reinterpret_cast<circle::HashtableImportOptionsT *>(u.value));
24162       break;
24163     }
24164     case BuiltinOptions_HashtableSizeOptions:
24165     {
24166       value = new circle::HashtableSizeOptionsT(
24167         *reinterpret_cast<circle::HashtableSizeOptionsT *>(u.value));
24168       break;
24169     }
24170     case BuiltinOptions_VarHandleOptions:
24171     {
24172       value =
24173         new circle::VarHandleOptionsT(*reinterpret_cast<circle::VarHandleOptionsT *>(u.value));
24174       break;
24175     }
24176     case BuiltinOptions_ReadVariableOptions:
24177     {
24178       value = new circle::ReadVariableOptionsT(
24179         *reinterpret_cast<circle::ReadVariableOptionsT *>(u.value));
24180       break;
24181     }
24182     case BuiltinOptions_AssignVariableOptions:
24183     {
24184       value = new circle::AssignVariableOptionsT(
24185         *reinterpret_cast<circle::AssignVariableOptionsT *>(u.value));
24186       break;
24187     }
24188     case BuiltinOptions_RandomOptions:
24189     {
24190       value = new circle::RandomOptionsT(*reinterpret_cast<circle::RandomOptionsT *>(u.value));
24191       break;
24192     }
24193     case BuiltinOptions_BCQGatherOptions:
24194     {
24195       value =
24196         new circle::BCQGatherOptionsT(*reinterpret_cast<circle::BCQGatherOptionsT *>(u.value));
24197       break;
24198     }
24199     case BuiltinOptions_BCQFullyConnectedOptions:
24200     {
24201       value = new circle::BCQFullyConnectedOptionsT(
24202         *reinterpret_cast<circle::BCQFullyConnectedOptionsT *>(u.value));
24203       break;
24204     }
24205     case BuiltinOptions_InstanceNormOptions:
24206     {
24207       value = new circle::InstanceNormOptionsT(
24208         *reinterpret_cast<circle::InstanceNormOptionsT *>(u.value));
24209       break;
24210     }
24211     default:
24212       break;
24213   }
24214 }
24215
24216 inline void BuiltinOptionsUnion::Reset()
24217 {
24218   switch (type)
24219   {
24220     case BuiltinOptions_Conv2DOptions:
24221     {
24222       auto ptr = reinterpret_cast<circle::Conv2DOptionsT *>(value);
24223       delete ptr;
24224       break;
24225     }
24226     case BuiltinOptions_DepthwiseConv2DOptions:
24227     {
24228       auto ptr = reinterpret_cast<circle::DepthwiseConv2DOptionsT *>(value);
24229       delete ptr;
24230       break;
24231     }
24232     case BuiltinOptions_ConcatEmbeddingsOptions:
24233     {
24234       auto ptr = reinterpret_cast<circle::ConcatEmbeddingsOptionsT *>(value);
24235       delete ptr;
24236       break;
24237     }
24238     case BuiltinOptions_LSHProjectionOptions:
24239     {
24240       auto ptr = reinterpret_cast<circle::LSHProjectionOptionsT *>(value);
24241       delete ptr;
24242       break;
24243     }
24244     case BuiltinOptions_Pool2DOptions:
24245     {
24246       auto ptr = reinterpret_cast<circle::Pool2DOptionsT *>(value);
24247       delete ptr;
24248       break;
24249     }
24250     case BuiltinOptions_SVDFOptions:
24251     {
24252       auto ptr = reinterpret_cast<circle::SVDFOptionsT *>(value);
24253       delete ptr;
24254       break;
24255     }
24256     case BuiltinOptions_RNNOptions:
24257     {
24258       auto ptr = reinterpret_cast<circle::RNNOptionsT *>(value);
24259       delete ptr;
24260       break;
24261     }
24262     case BuiltinOptions_FullyConnectedOptions:
24263     {
24264       auto ptr = reinterpret_cast<circle::FullyConnectedOptionsT *>(value);
24265       delete ptr;
24266       break;
24267     }
24268     case BuiltinOptions_SoftmaxOptions:
24269     {
24270       auto ptr = reinterpret_cast<circle::SoftmaxOptionsT *>(value);
24271       delete ptr;
24272       break;
24273     }
24274     case BuiltinOptions_ConcatenationOptions:
24275     {
24276       auto ptr = reinterpret_cast<circle::ConcatenationOptionsT *>(value);
24277       delete ptr;
24278       break;
24279     }
24280     case BuiltinOptions_AddOptions:
24281     {
24282       auto ptr = reinterpret_cast<circle::AddOptionsT *>(value);
24283       delete ptr;
24284       break;
24285     }
24286     case BuiltinOptions_L2NormOptions:
24287     {
24288       auto ptr = reinterpret_cast<circle::L2NormOptionsT *>(value);
24289       delete ptr;
24290       break;
24291     }
24292     case BuiltinOptions_LocalResponseNormalizationOptions:
24293     {
24294       auto ptr = reinterpret_cast<circle::LocalResponseNormalizationOptionsT *>(value);
24295       delete ptr;
24296       break;
24297     }
24298     case BuiltinOptions_LSTMOptions:
24299     {
24300       auto ptr = reinterpret_cast<circle::LSTMOptionsT *>(value);
24301       delete ptr;
24302       break;
24303     }
24304     case BuiltinOptions_ResizeBilinearOptions:
24305     {
24306       auto ptr = reinterpret_cast<circle::ResizeBilinearOptionsT *>(value);
24307       delete ptr;
24308       break;
24309     }
24310     case BuiltinOptions_CallOptions:
24311     {
24312       auto ptr = reinterpret_cast<circle::CallOptionsT *>(value);
24313       delete ptr;
24314       break;
24315     }
24316     case BuiltinOptions_ReshapeOptions:
24317     {
24318       auto ptr = reinterpret_cast<circle::ReshapeOptionsT *>(value);
24319       delete ptr;
24320       break;
24321     }
24322     case BuiltinOptions_SkipGramOptions:
24323     {
24324       auto ptr = reinterpret_cast<circle::SkipGramOptionsT *>(value);
24325       delete ptr;
24326       break;
24327     }
24328     case BuiltinOptions_SpaceToDepthOptions:
24329     {
24330       auto ptr = reinterpret_cast<circle::SpaceToDepthOptionsT *>(value);
24331       delete ptr;
24332       break;
24333     }
24334     case BuiltinOptions_EmbeddingLookupSparseOptions:
24335     {
24336       auto ptr = reinterpret_cast<circle::EmbeddingLookupSparseOptionsT *>(value);
24337       delete ptr;
24338       break;
24339     }
24340     case BuiltinOptions_MulOptions:
24341     {
24342       auto ptr = reinterpret_cast<circle::MulOptionsT *>(value);
24343       delete ptr;
24344       break;
24345     }
24346     case BuiltinOptions_PadOptions:
24347     {
24348       auto ptr = reinterpret_cast<circle::PadOptionsT *>(value);
24349       delete ptr;
24350       break;
24351     }
24352     case BuiltinOptions_GatherOptions:
24353     {
24354       auto ptr = reinterpret_cast<circle::GatherOptionsT *>(value);
24355       delete ptr;
24356       break;
24357     }
24358     case BuiltinOptions_BatchToSpaceNDOptions:
24359     {
24360       auto ptr = reinterpret_cast<circle::BatchToSpaceNDOptionsT *>(value);
24361       delete ptr;
24362       break;
24363     }
24364     case BuiltinOptions_SpaceToBatchNDOptions:
24365     {
24366       auto ptr = reinterpret_cast<circle::SpaceToBatchNDOptionsT *>(value);
24367       delete ptr;
24368       break;
24369     }
24370     case BuiltinOptions_TransposeOptions:
24371     {
24372       auto ptr = reinterpret_cast<circle::TransposeOptionsT *>(value);
24373       delete ptr;
24374       break;
24375     }
24376     case BuiltinOptions_ReducerOptions:
24377     {
24378       auto ptr = reinterpret_cast<circle::ReducerOptionsT *>(value);
24379       delete ptr;
24380       break;
24381     }
24382     case BuiltinOptions_SubOptions:
24383     {
24384       auto ptr = reinterpret_cast<circle::SubOptionsT *>(value);
24385       delete ptr;
24386       break;
24387     }
24388     case BuiltinOptions_DivOptions:
24389     {
24390       auto ptr = reinterpret_cast<circle::DivOptionsT *>(value);
24391       delete ptr;
24392       break;
24393     }
24394     case BuiltinOptions_SqueezeOptions:
24395     {
24396       auto ptr = reinterpret_cast<circle::SqueezeOptionsT *>(value);
24397       delete ptr;
24398       break;
24399     }
24400     case BuiltinOptions_SequenceRNNOptions:
24401     {
24402       auto ptr = reinterpret_cast<circle::SequenceRNNOptionsT *>(value);
24403       delete ptr;
24404       break;
24405     }
24406     case BuiltinOptions_StridedSliceOptions:
24407     {
24408       auto ptr = reinterpret_cast<circle::StridedSliceOptionsT *>(value);
24409       delete ptr;
24410       break;
24411     }
24412     case BuiltinOptions_ExpOptions:
24413     {
24414       auto ptr = reinterpret_cast<circle::ExpOptionsT *>(value);
24415       delete ptr;
24416       break;
24417     }
24418     case BuiltinOptions_TopKV2Options:
24419     {
24420       auto ptr = reinterpret_cast<circle::TopKV2OptionsT *>(value);
24421       delete ptr;
24422       break;
24423     }
24424     case BuiltinOptions_SplitOptions:
24425     {
24426       auto ptr = reinterpret_cast<circle::SplitOptionsT *>(value);
24427       delete ptr;
24428       break;
24429     }
24430     case BuiltinOptions_LogSoftmaxOptions:
24431     {
24432       auto ptr = reinterpret_cast<circle::LogSoftmaxOptionsT *>(value);
24433       delete ptr;
24434       break;
24435     }
24436     case BuiltinOptions_CastOptions:
24437     {
24438       auto ptr = reinterpret_cast<circle::CastOptionsT *>(value);
24439       delete ptr;
24440       break;
24441     }
24442     case BuiltinOptions_DequantizeOptions:
24443     {
24444       auto ptr = reinterpret_cast<circle::DequantizeOptionsT *>(value);
24445       delete ptr;
24446       break;
24447     }
24448     case BuiltinOptions_MaximumMinimumOptions:
24449     {
24450       auto ptr = reinterpret_cast<circle::MaximumMinimumOptionsT *>(value);
24451       delete ptr;
24452       break;
24453     }
24454     case BuiltinOptions_ArgMaxOptions:
24455     {
24456       auto ptr = reinterpret_cast<circle::ArgMaxOptionsT *>(value);
24457       delete ptr;
24458       break;
24459     }
24460     case BuiltinOptions_LessOptions:
24461     {
24462       auto ptr = reinterpret_cast<circle::LessOptionsT *>(value);
24463       delete ptr;
24464       break;
24465     }
24466     case BuiltinOptions_NegOptions:
24467     {
24468       auto ptr = reinterpret_cast<circle::NegOptionsT *>(value);
24469       delete ptr;
24470       break;
24471     }
24472     case BuiltinOptions_PadV2Options:
24473     {
24474       auto ptr = reinterpret_cast<circle::PadV2OptionsT *>(value);
24475       delete ptr;
24476       break;
24477     }
24478     case BuiltinOptions_GreaterOptions:
24479     {
24480       auto ptr = reinterpret_cast<circle::GreaterOptionsT *>(value);
24481       delete ptr;
24482       break;
24483     }
24484     case BuiltinOptions_GreaterEqualOptions:
24485     {
24486       auto ptr = reinterpret_cast<circle::GreaterEqualOptionsT *>(value);
24487       delete ptr;
24488       break;
24489     }
24490     case BuiltinOptions_LessEqualOptions:
24491     {
24492       auto ptr = reinterpret_cast<circle::LessEqualOptionsT *>(value);
24493       delete ptr;
24494       break;
24495     }
24496     case BuiltinOptions_SelectOptions:
24497     {
24498       auto ptr = reinterpret_cast<circle::SelectOptionsT *>(value);
24499       delete ptr;
24500       break;
24501     }
24502     case BuiltinOptions_SliceOptions:
24503     {
24504       auto ptr = reinterpret_cast<circle::SliceOptionsT *>(value);
24505       delete ptr;
24506       break;
24507     }
24508     case BuiltinOptions_TransposeConvOptions:
24509     {
24510       auto ptr = reinterpret_cast<circle::TransposeConvOptionsT *>(value);
24511       delete ptr;
24512       break;
24513     }
24514     case BuiltinOptions_SparseToDenseOptions:
24515     {
24516       auto ptr = reinterpret_cast<circle::SparseToDenseOptionsT *>(value);
24517       delete ptr;
24518       break;
24519     }
24520     case BuiltinOptions_TileOptions:
24521     {
24522       auto ptr = reinterpret_cast<circle::TileOptionsT *>(value);
24523       delete ptr;
24524       break;
24525     }
24526     case BuiltinOptions_ExpandDimsOptions:
24527     {
24528       auto ptr = reinterpret_cast<circle::ExpandDimsOptionsT *>(value);
24529       delete ptr;
24530       break;
24531     }
24532     case BuiltinOptions_EqualOptions:
24533     {
24534       auto ptr = reinterpret_cast<circle::EqualOptionsT *>(value);
24535       delete ptr;
24536       break;
24537     }
24538     case BuiltinOptions_NotEqualOptions:
24539     {
24540       auto ptr = reinterpret_cast<circle::NotEqualOptionsT *>(value);
24541       delete ptr;
24542       break;
24543     }
24544     case BuiltinOptions_ShapeOptions:
24545     {
24546       auto ptr = reinterpret_cast<circle::ShapeOptionsT *>(value);
24547       delete ptr;
24548       break;
24549     }
24550     case BuiltinOptions_PowOptions:
24551     {
24552       auto ptr = reinterpret_cast<circle::PowOptionsT *>(value);
24553       delete ptr;
24554       break;
24555     }
24556     case BuiltinOptions_ArgMinOptions:
24557     {
24558       auto ptr = reinterpret_cast<circle::ArgMinOptionsT *>(value);
24559       delete ptr;
24560       break;
24561     }
24562     case BuiltinOptions_FakeQuantOptions:
24563     {
24564       auto ptr = reinterpret_cast<circle::FakeQuantOptionsT *>(value);
24565       delete ptr;
24566       break;
24567     }
24568     case BuiltinOptions_PackOptions:
24569     {
24570       auto ptr = reinterpret_cast<circle::PackOptionsT *>(value);
24571       delete ptr;
24572       break;
24573     }
24574     case BuiltinOptions_LogicalOrOptions:
24575     {
24576       auto ptr = reinterpret_cast<circle::LogicalOrOptionsT *>(value);
24577       delete ptr;
24578       break;
24579     }
24580     case BuiltinOptions_OneHotOptions:
24581     {
24582       auto ptr = reinterpret_cast<circle::OneHotOptionsT *>(value);
24583       delete ptr;
24584       break;
24585     }
24586     case BuiltinOptions_LogicalAndOptions:
24587     {
24588       auto ptr = reinterpret_cast<circle::LogicalAndOptionsT *>(value);
24589       delete ptr;
24590       break;
24591     }
24592     case BuiltinOptions_LogicalNotOptions:
24593     {
24594       auto ptr = reinterpret_cast<circle::LogicalNotOptionsT *>(value);
24595       delete ptr;
24596       break;
24597     }
24598     case BuiltinOptions_UnpackOptions:
24599     {
24600       auto ptr = reinterpret_cast<circle::UnpackOptionsT *>(value);
24601       delete ptr;
24602       break;
24603     }
24604     case BuiltinOptions_FloorDivOptions:
24605     {
24606       auto ptr = reinterpret_cast<circle::FloorDivOptionsT *>(value);
24607       delete ptr;
24608       break;
24609     }
24610     case BuiltinOptions_SquareOptions:
24611     {
24612       auto ptr = reinterpret_cast<circle::SquareOptionsT *>(value);
24613       delete ptr;
24614       break;
24615     }
24616     case BuiltinOptions_ZerosLikeOptions:
24617     {
24618       auto ptr = reinterpret_cast<circle::ZerosLikeOptionsT *>(value);
24619       delete ptr;
24620       break;
24621     }
24622     case BuiltinOptions_FillOptions:
24623     {
24624       auto ptr = reinterpret_cast<circle::FillOptionsT *>(value);
24625       delete ptr;
24626       break;
24627     }
24628     case BuiltinOptions_BidirectionalSequenceLSTMOptions:
24629     {
24630       auto ptr = reinterpret_cast<circle::BidirectionalSequenceLSTMOptionsT *>(value);
24631       delete ptr;
24632       break;
24633     }
24634     case BuiltinOptions_BidirectionalSequenceRNNOptions:
24635     {
24636       auto ptr = reinterpret_cast<circle::BidirectionalSequenceRNNOptionsT *>(value);
24637       delete ptr;
24638       break;
24639     }
24640     case BuiltinOptions_UnidirectionalSequenceLSTMOptions:
24641     {
24642       auto ptr = reinterpret_cast<circle::UnidirectionalSequenceLSTMOptionsT *>(value);
24643       delete ptr;
24644       break;
24645     }
24646     case BuiltinOptions_FloorModOptions:
24647     {
24648       auto ptr = reinterpret_cast<circle::FloorModOptionsT *>(value);
24649       delete ptr;
24650       break;
24651     }
24652     case BuiltinOptions_RangeOptions:
24653     {
24654       auto ptr = reinterpret_cast<circle::RangeOptionsT *>(value);
24655       delete ptr;
24656       break;
24657     }
24658     case BuiltinOptions_ResizeNearestNeighborOptions:
24659     {
24660       auto ptr = reinterpret_cast<circle::ResizeNearestNeighborOptionsT *>(value);
24661       delete ptr;
24662       break;
24663     }
24664     case BuiltinOptions_LeakyReluOptions:
24665     {
24666       auto ptr = reinterpret_cast<circle::LeakyReluOptionsT *>(value);
24667       delete ptr;
24668       break;
24669     }
24670     case BuiltinOptions_SquaredDifferenceOptions:
24671     {
24672       auto ptr = reinterpret_cast<circle::SquaredDifferenceOptionsT *>(value);
24673       delete ptr;
24674       break;
24675     }
24676     case BuiltinOptions_MirrorPadOptions:
24677     {
24678       auto ptr = reinterpret_cast<circle::MirrorPadOptionsT *>(value);
24679       delete ptr;
24680       break;
24681     }
24682     case BuiltinOptions_AbsOptions:
24683     {
24684       auto ptr = reinterpret_cast<circle::AbsOptionsT *>(value);
24685       delete ptr;
24686       break;
24687     }
24688     case BuiltinOptions_SplitVOptions:
24689     {
24690       auto ptr = reinterpret_cast<circle::SplitVOptionsT *>(value);
24691       delete ptr;
24692       break;
24693     }
24694     case BuiltinOptions_UniqueOptions:
24695     {
24696       auto ptr = reinterpret_cast<circle::UniqueOptionsT *>(value);
24697       delete ptr;
24698       break;
24699     }
24700     case BuiltinOptions_ReverseV2Options:
24701     {
24702       auto ptr = reinterpret_cast<circle::ReverseV2OptionsT *>(value);
24703       delete ptr;
24704       break;
24705     }
24706     case BuiltinOptions_AddNOptions:
24707     {
24708       auto ptr = reinterpret_cast<circle::AddNOptionsT *>(value);
24709       delete ptr;
24710       break;
24711     }
24712     case BuiltinOptions_GatherNdOptions:
24713     {
24714       auto ptr = reinterpret_cast<circle::GatherNdOptionsT *>(value);
24715       delete ptr;
24716       break;
24717     }
24718     case BuiltinOptions_CosOptions:
24719     {
24720       auto ptr = reinterpret_cast<circle::CosOptionsT *>(value);
24721       delete ptr;
24722       break;
24723     }
24724     case BuiltinOptions_WhereOptions:
24725     {
24726       auto ptr = reinterpret_cast<circle::WhereOptionsT *>(value);
24727       delete ptr;
24728       break;
24729     }
24730     case BuiltinOptions_RankOptions:
24731     {
24732       auto ptr = reinterpret_cast<circle::RankOptionsT *>(value);
24733       delete ptr;
24734       break;
24735     }
24736     case BuiltinOptions_ReverseSequenceOptions:
24737     {
24738       auto ptr = reinterpret_cast<circle::ReverseSequenceOptionsT *>(value);
24739       delete ptr;
24740       break;
24741     }
24742     case BuiltinOptions_MatrixDiagOptions:
24743     {
24744       auto ptr = reinterpret_cast<circle::MatrixDiagOptionsT *>(value);
24745       delete ptr;
24746       break;
24747     }
24748     case BuiltinOptions_QuantizeOptions:
24749     {
24750       auto ptr = reinterpret_cast<circle::QuantizeOptionsT *>(value);
24751       delete ptr;
24752       break;
24753     }
24754     case BuiltinOptions_MatrixSetDiagOptions:
24755     {
24756       auto ptr = reinterpret_cast<circle::MatrixSetDiagOptionsT *>(value);
24757       delete ptr;
24758       break;
24759     }
24760     case BuiltinOptions_HardSwishOptions:
24761     {
24762       auto ptr = reinterpret_cast<circle::HardSwishOptionsT *>(value);
24763       delete ptr;
24764       break;
24765     }
24766     case BuiltinOptions_IfOptions:
24767     {
24768       auto ptr = reinterpret_cast<circle::IfOptionsT *>(value);
24769       delete ptr;
24770       break;
24771     }
24772     case BuiltinOptions_WhileOptions:
24773     {
24774       auto ptr = reinterpret_cast<circle::WhileOptionsT *>(value);
24775       delete ptr;
24776       break;
24777     }
24778     case BuiltinOptions_DepthToSpaceOptions:
24779     {
24780       auto ptr = reinterpret_cast<circle::DepthToSpaceOptionsT *>(value);
24781       delete ptr;
24782       break;
24783     }
24784     case BuiltinOptions_NonMaxSuppressionV4Options:
24785     {
24786       auto ptr = reinterpret_cast<circle::NonMaxSuppressionV4OptionsT *>(value);
24787       delete ptr;
24788       break;
24789     }
24790     case BuiltinOptions_NonMaxSuppressionV5Options:
24791     {
24792       auto ptr = reinterpret_cast<circle::NonMaxSuppressionV5OptionsT *>(value);
24793       delete ptr;
24794       break;
24795     }
24796     case BuiltinOptions_ScatterNdOptions:
24797     {
24798       auto ptr = reinterpret_cast<circle::ScatterNdOptionsT *>(value);
24799       delete ptr;
24800       break;
24801     }
24802     case BuiltinOptions_SelectV2Options:
24803     {
24804       auto ptr = reinterpret_cast<circle::SelectV2OptionsT *>(value);
24805       delete ptr;
24806       break;
24807     }
24808     case BuiltinOptions_DensifyOptions:
24809     {
24810       auto ptr = reinterpret_cast<circle::DensifyOptionsT *>(value);
24811       delete ptr;
24812       break;
24813     }
24814     case BuiltinOptions_SegmentSumOptions:
24815     {
24816       auto ptr = reinterpret_cast<circle::SegmentSumOptionsT *>(value);
24817       delete ptr;
24818       break;
24819     }
24820     case BuiltinOptions_BatchMatMulOptions:
24821     {
24822       auto ptr = reinterpret_cast<circle::BatchMatMulOptionsT *>(value);
24823       delete ptr;
24824       break;
24825     }
24826     case BuiltinOptions_CumsumOptions:
24827     {
24828       auto ptr = reinterpret_cast<circle::CumsumOptionsT *>(value);
24829       delete ptr;
24830       break;
24831     }
24832     case BuiltinOptions_CallOnceOptions:
24833     {
24834       auto ptr = reinterpret_cast<circle::CallOnceOptionsT *>(value);
24835       delete ptr;
24836       break;
24837     }
24838     case BuiltinOptions_BroadcastToOptions:
24839     {
24840       auto ptr = reinterpret_cast<circle::BroadcastToOptionsT *>(value);
24841       delete ptr;
24842       break;
24843     }
24844     case BuiltinOptions_Rfft2dOptions:
24845     {
24846       auto ptr = reinterpret_cast<circle::Rfft2dOptionsT *>(value);
24847       delete ptr;
24848       break;
24849     }
24850     case BuiltinOptions_Conv3DOptions:
24851     {
24852       auto ptr = reinterpret_cast<circle::Conv3DOptionsT *>(value);
24853       delete ptr;
24854       break;
24855     }
24856     case BuiltinOptions_HashtableOptions:
24857     {
24858       auto ptr = reinterpret_cast<circle::HashtableOptionsT *>(value);
24859       delete ptr;
24860       break;
24861     }
24862     case BuiltinOptions_HashtableFindOptions:
24863     {
24864       auto ptr = reinterpret_cast<circle::HashtableFindOptionsT *>(value);
24865       delete ptr;
24866       break;
24867     }
24868     case BuiltinOptions_HashtableImportOptions:
24869     {
24870       auto ptr = reinterpret_cast<circle::HashtableImportOptionsT *>(value);
24871       delete ptr;
24872       break;
24873     }
24874     case BuiltinOptions_HashtableSizeOptions:
24875     {
24876       auto ptr = reinterpret_cast<circle::HashtableSizeOptionsT *>(value);
24877       delete ptr;
24878       break;
24879     }
24880     case BuiltinOptions_VarHandleOptions:
24881     {
24882       auto ptr = reinterpret_cast<circle::VarHandleOptionsT *>(value);
24883       delete ptr;
24884       break;
24885     }
24886     case BuiltinOptions_ReadVariableOptions:
24887     {
24888       auto ptr = reinterpret_cast<circle::ReadVariableOptionsT *>(value);
24889       delete ptr;
24890       break;
24891     }
24892     case BuiltinOptions_AssignVariableOptions:
24893     {
24894       auto ptr = reinterpret_cast<circle::AssignVariableOptionsT *>(value);
24895       delete ptr;
24896       break;
24897     }
24898     case BuiltinOptions_RandomOptions:
24899     {
24900       auto ptr = reinterpret_cast<circle::RandomOptionsT *>(value);
24901       delete ptr;
24902       break;
24903     }
24904     case BuiltinOptions_BCQGatherOptions:
24905     {
24906       auto ptr = reinterpret_cast<circle::BCQGatherOptionsT *>(value);
24907       delete ptr;
24908       break;
24909     }
24910     case BuiltinOptions_BCQFullyConnectedOptions:
24911     {
24912       auto ptr = reinterpret_cast<circle::BCQFullyConnectedOptionsT *>(value);
24913       delete ptr;
24914       break;
24915     }
24916     case BuiltinOptions_InstanceNormOptions:
24917     {
24918       auto ptr = reinterpret_cast<circle::InstanceNormOptionsT *>(value);
24919       delete ptr;
24920       break;
24921     }
24922     default:
24923       break;
24924   }
24925   value = nullptr;
24926   type = BuiltinOptions_NONE;
24927 }
24928
24929 inline const circle::Model *GetModel(const void *buf)
24930 {
24931   return flatbuffers::GetRoot<circle::Model>(buf);
24932 }
24933
24934 inline const circle::Model *GetSizePrefixedModel(const void *buf)
24935 {
24936   return flatbuffers::GetSizePrefixedRoot<circle::Model>(buf);
24937 }
24938
24939 inline const char *ModelIdentifier() { return "CIR0"; }
24940
24941 inline bool ModelBufferHasIdentifier(const void *buf)
24942 {
24943   return flatbuffers::BufferHasIdentifier(buf, ModelIdentifier());
24944 }
24945
24946 inline bool VerifyModelBuffer(flatbuffers::Verifier &verifier)
24947 {
24948   return verifier.VerifyBuffer<circle::Model>(ModelIdentifier());
24949 }
24950
24951 inline bool VerifySizePrefixedModelBuffer(flatbuffers::Verifier &verifier)
24952 {
24953   return verifier.VerifySizePrefixedBuffer<circle::Model>(ModelIdentifier());
24954 }
24955
24956 inline const char *ModelExtension() { return "circle"; }
24957
24958 inline void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
24959                               flatbuffers::Offset<circle::Model> root)
24960 {
24961   fbb.Finish(root, ModelIdentifier());
24962 }
24963
24964 inline void FinishSizePrefixedModelBuffer(flatbuffers::FlatBufferBuilder &fbb,
24965                                           flatbuffers::Offset<circle::Model> root)
24966 {
24967   fbb.FinishSizePrefixed(root, ModelIdentifier());
24968 }
24969
24970 inline std::unique_ptr<circle::ModelT>
24971 UnPackModel(const void *buf, const flatbuffers::resolver_function_t *res = nullptr)
24972 {
24973   return std::unique_ptr<circle::ModelT>(GetModel(buf)->UnPack(res));
24974 }
24975
24976 inline std::unique_ptr<circle::ModelT>
24977 UnPackSizePrefixedModel(const void *buf, const flatbuffers::resolver_function_t *res = nullptr)
24978 {
24979   return std::unique_ptr<circle::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
24980 }
24981
24982 } // namespace circle
24983
24984 #endif // FLATBUFFERS_GENERATED_SCHEMA_CIRCLE_H_