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

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