schema_generated.h source code [tensorflow/tensorflow/lite/schema/schema_generated.h]

1	/ Copyright 2018 The TensorFlow Authors. All Rights Reserved.*
2
3	Licensed under the Apache License, Version 2.0 (the "License");
4	you may not use this file except in compliance with the License.
5	You may obtain a copy of the License at
6
7	http://www.apache.org/licenses/LICENSE-2.0
8
9	Unless required by applicable law or agreed to in writing, software
10	distributed under the License is distributed on an "AS IS" BASIS,
11	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	See the License for the specific language governing permissions and
13	limitations under the License.
14	==============================================================================/*
15	// automatically generated by the FlatBuffers compiler, do not modify
16
17
18	#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
19	#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
20
21	#include "flatbuffers/flatbuffers.h"
22
23	namespace tflite {
24
25	struct CustomQuantization;
26	struct CustomQuantizationBuilder;
27	struct CustomQuantizationT;
28
29	struct QuantizationParameters;
30	struct QuantizationParametersBuilder;
31	struct QuantizationParametersT;
32
33	struct Int32Vector;
34	struct Int32VectorBuilder;
35	struct Int32VectorT;
36
37	struct Uint16Vector;
38	struct Uint16VectorBuilder;
39	struct Uint16VectorT;
40
41	struct Uint8Vector;
42	struct Uint8VectorBuilder;
43	struct Uint8VectorT;
44
45	struct DimensionMetadata;
46	struct DimensionMetadataBuilder;
47	struct DimensionMetadataT;
48
49	struct SparsityParameters;
50	struct SparsityParametersBuilder;
51	struct SparsityParametersT;
52
53	struct VariantSubType;
54	struct VariantSubTypeBuilder;
55	struct VariantSubTypeT;
56
57	struct Tensor;
58	struct TensorBuilder;
59	struct TensorT;
60
61	struct Conv2DOptions;
62	struct Conv2DOptionsBuilder;
63	struct Conv2DOptionsT;
64
65	struct Conv3DOptions;
66	struct Conv3DOptionsBuilder;
67	struct Conv3DOptionsT;
68
69	struct Pool2DOptions;
70	struct Pool2DOptionsBuilder;
71	struct Pool2DOptionsT;
72
73	struct DepthwiseConv2DOptions;
74	struct DepthwiseConv2DOptionsBuilder;
75	struct DepthwiseConv2DOptionsT;
76
77	struct ConcatEmbeddingsOptions;
78	struct ConcatEmbeddingsOptionsBuilder;
79	struct ConcatEmbeddingsOptionsT;
80
81	struct LSHProjectionOptions;
82	struct LSHProjectionOptionsBuilder;
83	struct LSHProjectionOptionsT;
84
85	struct SVDFOptions;
86	struct SVDFOptionsBuilder;
87	struct SVDFOptionsT;
88
89	struct RNNOptions;
90	struct RNNOptionsBuilder;
91	struct RNNOptionsT;
92
93	struct SequenceRNNOptions;
94	struct SequenceRNNOptionsBuilder;
95	struct SequenceRNNOptionsT;
96
97	struct BidirectionalSequenceRNNOptions;
98	struct BidirectionalSequenceRNNOptionsBuilder;
99	struct BidirectionalSequenceRNNOptionsT;
100
101	struct FullyConnectedOptions;
102	struct FullyConnectedOptionsBuilder;
103	struct FullyConnectedOptionsT;
104
105	struct SoftmaxOptions;
106	struct SoftmaxOptionsBuilder;
107	struct SoftmaxOptionsT;
108
109	struct ConcatenationOptions;
110	struct ConcatenationOptionsBuilder;
111	struct ConcatenationOptionsT;
112
113	struct AddOptions;
114	struct AddOptionsBuilder;
115	struct AddOptionsT;
116
117	struct MulOptions;
118	struct MulOptionsBuilder;
119	struct MulOptionsT;
120
121	struct L2NormOptions;
122	struct L2NormOptionsBuilder;
123	struct L2NormOptionsT;
124
125	struct LocalResponseNormalizationOptions;
126	struct LocalResponseNormalizationOptionsBuilder;
127	struct LocalResponseNormalizationOptionsT;
128
129	struct LSTMOptions;
130	struct LSTMOptionsBuilder;
131	struct LSTMOptionsT;
132
133	struct UnidirectionalSequenceLSTMOptions;
134	struct UnidirectionalSequenceLSTMOptionsBuilder;
135	struct UnidirectionalSequenceLSTMOptionsT;
136
137	struct BidirectionalSequenceLSTMOptions;
138	struct BidirectionalSequenceLSTMOptionsBuilder;
139	struct BidirectionalSequenceLSTMOptionsT;
140
141	struct ResizeBilinearOptions;
142	struct ResizeBilinearOptionsBuilder;
143	struct ResizeBilinearOptionsT;
144
145	struct ResizeNearestNeighborOptions;
146	struct ResizeNearestNeighborOptionsBuilder;
147	struct ResizeNearestNeighborOptionsT;
148
149	struct CallOptions;
150	struct CallOptionsBuilder;
151	struct CallOptionsT;
152
153	struct PadOptions;
154	struct PadOptionsBuilder;
155	struct PadOptionsT;
156
157	struct PadV2Options;
158	struct PadV2OptionsBuilder;
159	struct PadV2OptionsT;
160
161	struct ReshapeOptions;
162	struct ReshapeOptionsBuilder;
163	struct ReshapeOptionsT;
164
165	struct SpaceToBatchNDOptions;
166	struct SpaceToBatchNDOptionsBuilder;
167	struct SpaceToBatchNDOptionsT;
168
169	struct BatchToSpaceNDOptions;
170	struct BatchToSpaceNDOptionsBuilder;
171	struct BatchToSpaceNDOptionsT;
172
173	struct SkipGramOptions;
174	struct SkipGramOptionsBuilder;
175	struct SkipGramOptionsT;
176
177	struct SpaceToDepthOptions;
178	struct SpaceToDepthOptionsBuilder;
179	struct SpaceToDepthOptionsT;
180
181	struct DepthToSpaceOptions;
182	struct DepthToSpaceOptionsBuilder;
183	struct DepthToSpaceOptionsT;
184
185	struct SubOptions;
186	struct SubOptionsBuilder;
187	struct SubOptionsT;
188
189	struct DivOptions;
190	struct DivOptionsBuilder;
191	struct DivOptionsT;
192
193	struct TopKV2Options;
194	struct TopKV2OptionsBuilder;
195	struct TopKV2OptionsT;
196
197	struct EmbeddingLookupSparseOptions;
198	struct EmbeddingLookupSparseOptionsBuilder;
199	struct EmbeddingLookupSparseOptionsT;
200
201	struct GatherOptions;
202	struct GatherOptionsBuilder;
203	struct GatherOptionsT;
204
205	struct TransposeOptions;
206	struct TransposeOptionsBuilder;
207	struct TransposeOptionsT;
208
209	struct ExpOptions;
210	struct ExpOptionsBuilder;
211	struct ExpOptionsT;
212
213	struct CosOptions;
214	struct CosOptionsBuilder;
215	struct CosOptionsT;
216
217	struct ReducerOptions;
218	struct ReducerOptionsBuilder;
219	struct ReducerOptionsT;
220
221	struct SqueezeOptions;
222	struct SqueezeOptionsBuilder;
223	struct SqueezeOptionsT;
224
225	struct SplitOptions;
226	struct SplitOptionsBuilder;
227	struct SplitOptionsT;
228
229	struct SplitVOptions;
230	struct SplitVOptionsBuilder;
231	struct SplitVOptionsT;
232
233	struct StridedSliceOptions;
234	struct StridedSliceOptionsBuilder;
235	struct StridedSliceOptionsT;
236
237	struct LogSoftmaxOptions;
238	struct LogSoftmaxOptionsBuilder;
239	struct LogSoftmaxOptionsT;
240
241	struct CastOptions;
242	struct CastOptionsBuilder;
243	struct CastOptionsT;
244
245	struct DequantizeOptions;
246	struct DequantizeOptionsBuilder;
247	struct DequantizeOptionsT;
248
249	struct MaximumMinimumOptions;
250	struct MaximumMinimumOptionsBuilder;
251	struct MaximumMinimumOptionsT;
252
253	struct TileOptions;
254	struct TileOptionsBuilder;
255	struct TileOptionsT;
256
257	struct ArgMaxOptions;
258	struct ArgMaxOptionsBuilder;
259	struct ArgMaxOptionsT;
260
261	struct ArgMinOptions;
262	struct ArgMinOptionsBuilder;
263	struct ArgMinOptionsT;
264
265	struct GreaterOptions;
266	struct GreaterOptionsBuilder;
267	struct GreaterOptionsT;
268
269	struct GreaterEqualOptions;
270	struct GreaterEqualOptionsBuilder;
271	struct GreaterEqualOptionsT;
272
273	struct LessOptions;
274	struct LessOptionsBuilder;
275	struct LessOptionsT;
276
277	struct LessEqualOptions;
278	struct LessEqualOptionsBuilder;
279	struct LessEqualOptionsT;
280
281	struct NegOptions;
282	struct NegOptionsBuilder;
283	struct NegOptionsT;
284
285	struct SelectOptions;
286	struct SelectOptionsBuilder;
287	struct SelectOptionsT;
288
289	struct SliceOptions;
290	struct SliceOptionsBuilder;
291	struct SliceOptionsT;
292
293	struct TransposeConvOptions;
294	struct TransposeConvOptionsBuilder;
295	struct TransposeConvOptionsT;
296
297	struct ExpandDimsOptions;
298	struct ExpandDimsOptionsBuilder;
299	struct ExpandDimsOptionsT;
300
301	struct SparseToDenseOptions;
302	struct SparseToDenseOptionsBuilder;
303	struct SparseToDenseOptionsT;
304
305	struct EqualOptions;
306	struct EqualOptionsBuilder;
307	struct EqualOptionsT;
308
309	struct NotEqualOptions;
310	struct NotEqualOptionsBuilder;
311	struct NotEqualOptionsT;
312
313	struct ShapeOptions;
314	struct ShapeOptionsBuilder;
315	struct ShapeOptionsT;
316
317	struct RankOptions;
318	struct RankOptionsBuilder;
319	struct RankOptionsT;
320
321	struct PowOptions;
322	struct PowOptionsBuilder;
323	struct PowOptionsT;
324
325	struct FakeQuantOptions;
326	struct FakeQuantOptionsBuilder;
327	struct FakeQuantOptionsT;
328
329	struct PackOptions;
330	struct PackOptionsBuilder;
331	struct PackOptionsT;
332
333	struct LogicalOrOptions;
334	struct LogicalOrOptionsBuilder;
335	struct LogicalOrOptionsT;
336
337	struct OneHotOptions;
338	struct OneHotOptionsBuilder;
339	struct OneHotOptionsT;
340
341	struct AbsOptions;
342	struct AbsOptionsBuilder;
343	struct AbsOptionsT;
344
345	struct HardSwishOptions;
346	struct HardSwishOptionsBuilder;
347	struct HardSwishOptionsT;
348
349	struct LogicalAndOptions;
350	struct LogicalAndOptionsBuilder;
351	struct LogicalAndOptionsT;
352
353	struct LogicalNotOptions;
354	struct LogicalNotOptionsBuilder;
355	struct LogicalNotOptionsT;
356
357	struct UnpackOptions;
358	struct UnpackOptionsBuilder;
359	struct UnpackOptionsT;
360
361	struct FloorDivOptions;
362	struct FloorDivOptionsBuilder;
363	struct FloorDivOptionsT;
364
365	struct SquareOptions;
366	struct SquareOptionsBuilder;
367	struct SquareOptionsT;
368
369	struct ZerosLikeOptions;
370	struct ZerosLikeOptionsBuilder;
371	struct ZerosLikeOptionsT;
372
373	struct FillOptions;
374	struct FillOptionsBuilder;
375	struct FillOptionsT;
376
377	struct FloorModOptions;
378	struct FloorModOptionsBuilder;
379	struct FloorModOptionsT;
380
381	struct RangeOptions;
382	struct RangeOptionsBuilder;
383	struct RangeOptionsT;
384
385	struct LeakyReluOptions;
386	struct LeakyReluOptionsBuilder;
387	struct LeakyReluOptionsT;
388
389	struct SquaredDifferenceOptions;
390	struct SquaredDifferenceOptionsBuilder;
391	struct SquaredDifferenceOptionsT;
392
393	struct MirrorPadOptions;
394	struct MirrorPadOptionsBuilder;
395	struct MirrorPadOptionsT;
396
397	struct UniqueOptions;
398	struct UniqueOptionsBuilder;
399	struct UniqueOptionsT;
400
401	struct ReverseV2Options;
402	struct ReverseV2OptionsBuilder;
403	struct ReverseV2OptionsT;
404
405	struct AddNOptions;
406	struct AddNOptionsBuilder;
407	struct AddNOptionsT;
408
409	struct GatherNdOptions;
410	struct GatherNdOptionsBuilder;
411	struct GatherNdOptionsT;
412
413	struct WhereOptions;
414	struct WhereOptionsBuilder;
415	struct WhereOptionsT;
416
417	struct ReverseSequenceOptions;
418	struct ReverseSequenceOptionsBuilder;
419	struct ReverseSequenceOptionsT;
420
421	struct MatrixDiagOptions;
422	struct MatrixDiagOptionsBuilder;
423	struct MatrixDiagOptionsT;
424
425	struct QuantizeOptions;
426	struct QuantizeOptionsBuilder;
427	struct QuantizeOptionsT;
428
429	struct MatrixSetDiagOptions;
430	struct MatrixSetDiagOptionsBuilder;
431	struct MatrixSetDiagOptionsT;
432
433	struct IfOptions;
434	struct IfOptionsBuilder;
435	struct IfOptionsT;
436
437	struct CallOnceOptions;
438	struct CallOnceOptionsBuilder;
439	struct CallOnceOptionsT;
440
441	struct WhileOptions;
442	struct WhileOptionsBuilder;
443	struct WhileOptionsT;
444
445	struct NonMaxSuppressionV4Options;
446	struct NonMaxSuppressionV4OptionsBuilder;
447	struct NonMaxSuppressionV4OptionsT;
448
449	struct NonMaxSuppressionV5Options;
450	struct NonMaxSuppressionV5OptionsBuilder;
451	struct NonMaxSuppressionV5OptionsT;
452
453	struct ScatterNdOptions;
454	struct ScatterNdOptionsBuilder;
455	struct ScatterNdOptionsT;
456
457	struct SelectV2Options;
458	struct SelectV2OptionsBuilder;
459	struct SelectV2OptionsT;
460
461	struct DensifyOptions;
462	struct DensifyOptionsBuilder;
463	struct DensifyOptionsT;
464
465	struct SegmentSumOptions;
466	struct SegmentSumOptionsBuilder;
467	struct SegmentSumOptionsT;
468
469	struct BatchMatMulOptions;
470	struct BatchMatMulOptionsBuilder;
471	struct BatchMatMulOptionsT;
472
473	struct CumsumOptions;
474	struct CumsumOptionsBuilder;
475	struct CumsumOptionsT;
476
477	struct BroadcastToOptions;
478	struct BroadcastToOptionsBuilder;
479	struct BroadcastToOptionsT;
480
481	struct Rfft2dOptions;
482	struct Rfft2dOptionsBuilder;
483	struct Rfft2dOptionsT;
484
485	struct HashtableOptions;
486	struct HashtableOptionsBuilder;
487	struct HashtableOptionsT;
488
489	struct HashtableFindOptions;
490	struct HashtableFindOptionsBuilder;
491	struct HashtableFindOptionsT;
492
493	struct HashtableImportOptions;
494	struct HashtableImportOptionsBuilder;
495	struct HashtableImportOptionsT;
496
497	struct HashtableSizeOptions;
498	struct HashtableSizeOptionsBuilder;
499	struct HashtableSizeOptionsT;
500
501	struct VarHandleOptions;
502	struct VarHandleOptionsBuilder;
503	struct VarHandleOptionsT;
504
505	struct ReadVariableOptions;
506	struct ReadVariableOptionsBuilder;
507	struct ReadVariableOptionsT;
508
509	struct AssignVariableOptions;
510	struct AssignVariableOptionsBuilder;
511	struct AssignVariableOptionsT;
512
513	struct RandomOptions;
514	struct RandomOptionsBuilder;
515	struct RandomOptionsT;
516
517	struct BucketizeOptions;
518	struct BucketizeOptionsBuilder;
519	struct BucketizeOptionsT;
520
521	struct GeluOptions;
522	struct GeluOptionsBuilder;
523	struct GeluOptionsT;
524
525	struct DynamicUpdateSliceOptions;
526	struct DynamicUpdateSliceOptionsBuilder;
527	struct DynamicUpdateSliceOptionsT;
528
529	struct UnsortedSegmentProdOptions;
530	struct UnsortedSegmentProdOptionsBuilder;
531	struct UnsortedSegmentProdOptionsT;
532
533	struct UnsortedSegmentMaxOptions;
534	struct UnsortedSegmentMaxOptionsBuilder;
535	struct UnsortedSegmentMaxOptionsT;
536
537	struct UnsortedSegmentSumOptions;
538	struct UnsortedSegmentSumOptionsBuilder;
539	struct UnsortedSegmentSumOptionsT;
540
541	struct ATan2Options;
542	struct ATan2OptionsBuilder;
543	struct ATan2OptionsT;
544
545	struct UnsortedSegmentMinOptions;
546	struct UnsortedSegmentMinOptionsBuilder;
547	struct UnsortedSegmentMinOptionsT;
548
549	struct SignOptions;
550	struct SignOptionsBuilder;
551	struct SignOptionsT;
552
553	struct OperatorCode;
554	struct OperatorCodeBuilder;
555	struct OperatorCodeT;
556
557	struct Operator;
558	struct OperatorBuilder;
559	struct OperatorT;
560
561	struct SubGraph;
562	struct SubGraphBuilder;
563	struct SubGraphT;
564
565	struct Buffer;
566	struct BufferBuilder;
567	struct BufferT;
568
569	struct Metadata;
570	struct MetadataBuilder;
571	struct MetadataT;
572
573	struct TensorMap;
574	struct TensorMapBuilder;
575	struct TensorMapT;
576
577	struct SignatureDef;
578	struct SignatureDefBuilder;
579	struct SignatureDefT;
580
581	struct Model;
582	struct ModelBuilder;
583	struct ModelT;
584
585	enum TensorType : int8_t {
586	TensorType_FLOAT32 = `0`,
587	TensorType_FLOAT16 = `1`,
588	TensorType_INT32 = `2`,
589	TensorType_UINT8 = `3`,
590	TensorType_INT64 = `4`,
591	TensorType_STRING = `5`,
592	TensorType_BOOL = `6`,
593	TensorType_INT16 = `7`,
594	TensorType_COMPLEX64 = `8`,
595	TensorType_INT8 = `9`,
596	TensorType_FLOAT64 = `10`,
597	TensorType_COMPLEX128 = `11`,
598	TensorType_UINT64 = `12`,
599	TensorType_RESOURCE = `13`,
600	TensorType_VARIANT = `14`,
601	TensorType_UINT32 = `15`,
602	TensorType_UINT16 = `16`,
603	TensorType_MIN = TensorType_FLOAT32,
604	TensorType_MAX = TensorType_UINT16
605	};
606
607	inline const TensorType (&EnumValuesTensorType())[`17`] {
608	static const TensorType values[] = {
609	TensorType_FLOAT32,
610	TensorType_FLOAT16,
611	TensorType_INT32,
612	TensorType_UINT8,
613	TensorType_INT64,
614	TensorType_STRING,
615	TensorType_BOOL,
616	TensorType_INT16,
617	TensorType_COMPLEX64,
618	TensorType_INT8,
619	TensorType_FLOAT64,
620	TensorType_COMPLEX128,
621	TensorType_UINT64,
622	TensorType_RESOURCE,
623	TensorType_VARIANT,
624	TensorType_UINT32,
625	TensorType_UINT16
626	};
627	return values;
628	}
629
630	inline const char * const *EnumNamesTensorType() {
631	static const char * const names[`18`] = {
632	"FLOAT32",
633	"FLOAT16",
634	"INT32",
635	"UINT8",
636	"INT64",
637	"STRING",
638	"BOOL",
639	"INT16",
640	"COMPLEX64",
641	"INT8",
642	"FLOAT64",
643	"COMPLEX128",
644	"UINT64",
645	"RESOURCE",
646	"VARIANT",
647	"UINT32",
648	"UINT16",
649	nullptr
650	};
651	return names;
652	}
653
654	inline const char *EnumNameTensorType(TensorType e) {
655	if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT16)) return "";
656	const size_t index = static_cast<size_t>(e);
657	return EnumNamesTensorType()[index];
658	}
659
660	enum QuantizationDetails : uint8_t {
661	QuantizationDetails_NONE = `0`,
662	QuantizationDetails_CustomQuantization = `1`,
663	QuantizationDetails_MIN = QuantizationDetails_NONE,
664	QuantizationDetails_MAX = QuantizationDetails_CustomQuantization
665	};
666
667	inline const QuantizationDetails (&EnumValuesQuantizationDetails())[`2`] {
668	static const QuantizationDetails values[] = {
669	QuantizationDetails_NONE,
670	QuantizationDetails_CustomQuantization
671	};
672	return values;
673	}
674
675	inline const char * const *EnumNamesQuantizationDetails() {
676	static const char * const names[`3`] = {
677	"NONE",
678	"CustomQuantization",
679	nullptr
680	};
681	return names;
682	}
683
684	inline const char *EnumNameQuantizationDetails(QuantizationDetails e) {
685	if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return "";
686	const size_t index = static_cast<size_t>(e);
687	return EnumNamesQuantizationDetails()[index];
688	}
689
690	template<typename T> struct QuantizationDetailsTraits {
691	static const QuantizationDetails enum_value = QuantizationDetails_NONE;
692	};
693
694	template<> struct QuantizationDetailsTraits<tflite::CustomQuantization> {
695	static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
696	};
697
698	template<typename T> struct QuantizationDetailsUnionTraits {
699	static const QuantizationDetails enum_value = QuantizationDetails_NONE;
700	};
701
702	template<> struct QuantizationDetailsUnionTraits<tflite::CustomQuantizationT> {
703	static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization;
704	};
705
706	struct QuantizationDetailsUnion {
707	QuantizationDetails type;
708	void *value;
709
710	QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {}
711	QuantizationDetailsUnion(QuantizationDetailsUnion&& u) FLATBUFFERS_NOEXCEPT :
712	type(QuantizationDetails_NONE), value(nullptr)
713	{ std::swap(type, u.type); std::swap(value, u.value); }
714	QuantizationDetailsUnion(const QuantizationDetailsUnion &);
715	QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u)
716	{ QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
717	QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
718	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
719	~QuantizationDetailsUnion() { Reset(); }
720
721	void Reset();
722
723	template <typename T>
724	void Set(T&& val) {
725	typedef typename std::remove_reference<T>::type RT;
726	Reset();
727	type = QuantizationDetailsUnionTraits<RT>::enum_value;
728	if (type != QuantizationDetails_NONE) {
729	value = new RT(std::forward<T>(val));
730	}
731	}
732
733	static void UnPack(const* void obj, QuantizationDetails type, const* flatbuffers::resolver_function_t *resolver);
734	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
735
736	tflite::CustomQuantizationT *AsCustomQuantization() {
737	return type == QuantizationDetails_CustomQuantization ?
738	reinterpret_cast<tflite::CustomQuantizationT >(value) : nullptr*;
739	}
740	const tflite::CustomQuantizationT AsCustomQuantization() const* {
741	return type == QuantizationDetails_CustomQuantization ?
742	reinterpret_cast<const tflite::CustomQuantizationT >(value) : nullptr*;
743	}
744	};
745
746	bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
747	bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
748
749	enum DimensionType : int8_t {
750	DimensionType_DENSE = `0`,
751	DimensionType_SPARSE_CSR = `1`,
752	DimensionType_MIN = DimensionType_DENSE,
753	DimensionType_MAX = DimensionType_SPARSE_CSR
754	};
755
756	inline const DimensionType (&EnumValuesDimensionType())[`2`] {
757	static const DimensionType values[] = {
758	DimensionType_DENSE,
759	DimensionType_SPARSE_CSR
760	};
761	return values;
762	}
763
764	inline const char * const *EnumNamesDimensionType() {
765	static const char * const names[`3`] = {
766	"DENSE",
767	"SPARSE_CSR",
768	nullptr
769	};
770	return names;
771	}
772
773	inline const char *EnumNameDimensionType(DimensionType e) {
774	if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return "";
775	const size_t index = static_cast<size_t>(e);
776	return EnumNamesDimensionType()[index];
777	}
778
779	enum SparseIndexVector : uint8_t {
780	SparseIndexVector_NONE = `0`,
781	SparseIndexVector_Int32Vector = `1`,
782	SparseIndexVector_Uint16Vector = `2`,
783	SparseIndexVector_Uint8Vector = `3`,
784	SparseIndexVector_MIN = SparseIndexVector_NONE,
785	SparseIndexVector_MAX = SparseIndexVector_Uint8Vector
786	};
787
788	inline const SparseIndexVector (&EnumValuesSparseIndexVector())[`4`] {
789	static const SparseIndexVector values[] = {
790	SparseIndexVector_NONE,
791	SparseIndexVector_Int32Vector,
792	SparseIndexVector_Uint16Vector,
793	SparseIndexVector_Uint8Vector
794	};
795	return values;
796	}
797
798	inline const char * const *EnumNamesSparseIndexVector() {
799	static const char * const names[`5`] = {
800	"NONE",
801	"Int32Vector",
802	"Uint16Vector",
803	"Uint8Vector",
804	nullptr
805	};
806	return names;
807	}
808
809	inline const char *EnumNameSparseIndexVector(SparseIndexVector e) {
810	if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return "";
811	const size_t index = static_cast<size_t>(e);
812	return EnumNamesSparseIndexVector()[index];
813	}
814
815	template<typename T> struct SparseIndexVectorTraits {
816	static const SparseIndexVector enum_value = SparseIndexVector_NONE;
817	};
818
819	template<> struct SparseIndexVectorTraits<tflite::Int32Vector> {
820	static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
821	};
822
823	template<> struct SparseIndexVectorTraits<tflite::Uint16Vector> {
824	static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
825	};
826
827	template<> struct SparseIndexVectorTraits<tflite::Uint8Vector> {
828	static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
829	};
830
831	template<typename T> struct SparseIndexVectorUnionTraits {
832	static const SparseIndexVector enum_value = SparseIndexVector_NONE;
833	};
834
835	template<> struct SparseIndexVectorUnionTraits<tflite::Int32VectorT> {
836	static const SparseIndexVector enum_value = SparseIndexVector_Int32Vector;
837	};
838
839	template<> struct SparseIndexVectorUnionTraits<tflite::Uint16VectorT> {
840	static const SparseIndexVector enum_value = SparseIndexVector_Uint16Vector;
841	};
842
843	template<> struct SparseIndexVectorUnionTraits<tflite::Uint8VectorT> {
844	static const SparseIndexVector enum_value = SparseIndexVector_Uint8Vector;
845	};
846
847	struct SparseIndexVectorUnion {
848	SparseIndexVector type;
849	void *value;
850
851	SparseIndexVectorUnion() : type(SparseIndexVector_NONE), value(nullptr) {}
852	SparseIndexVectorUnion(SparseIndexVectorUnion&& u) FLATBUFFERS_NOEXCEPT :
853	type(SparseIndexVector_NONE), value(nullptr)
854	{ std::swap(type, u.type); std::swap(value, u.value); }
855	SparseIndexVectorUnion(const SparseIndexVectorUnion &);
856	SparseIndexVectorUnion &operator=(const SparseIndexVectorUnion &u)
857	{ SparseIndexVectorUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
858	SparseIndexVectorUnion &operator=(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
859	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
860	~SparseIndexVectorUnion() { Reset(); }
861
862	void Reset();
863
864	template <typename T>
865	void Set(T&& val) {
866	typedef typename std::remove_reference<T>::type RT;
867	Reset();
868	type = SparseIndexVectorUnionTraits<RT>::enum_value;
869	if (type != SparseIndexVector_NONE) {
870	value = new RT(std::forward<T>(val));
871	}
872	}
873
874	static void UnPack(const* void obj, SparseIndexVector type, const* flatbuffers::resolver_function_t *resolver);
875	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
876
877	tflite::Int32VectorT *AsInt32Vector() {
878	return type == SparseIndexVector_Int32Vector ?
879	reinterpret_cast<tflite::Int32VectorT >(value) : nullptr*;
880	}
881	const tflite::Int32VectorT AsInt32Vector() const* {
882	return type == SparseIndexVector_Int32Vector ?
883	reinterpret_cast<const tflite::Int32VectorT >(value) : nullptr*;
884	}
885	tflite::Uint16VectorT *AsUint16Vector() {
886	return type == SparseIndexVector_Uint16Vector ?
887	reinterpret_cast<tflite::Uint16VectorT >(value) : nullptr*;
888	}
889	const tflite::Uint16VectorT AsUint16Vector() const* {
890	return type == SparseIndexVector_Uint16Vector ?
891	reinterpret_cast<const tflite::Uint16VectorT >(value) : nullptr*;
892	}
893	tflite::Uint8VectorT *AsUint8Vector() {
894	return type == SparseIndexVector_Uint8Vector ?
895	reinterpret_cast<tflite::Uint8VectorT >(value) : nullptr*;
896	}
897	const tflite::Uint8VectorT AsUint8Vector() const* {
898	return type == SparseIndexVector_Uint8Vector ?
899	reinterpret_cast<const tflite::Uint8VectorT >(value) : nullptr*;
900	}
901	};
902
903	bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
904	bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
905
906	enum BuiltinOperator : int32_t {
907	BuiltinOperator_ADD = `0`,
908	BuiltinOperator_AVERAGE_POOL_2D = `1`,
909	BuiltinOperator_CONCATENATION = `2`,
910	BuiltinOperator_CONV_2D = `3`,
911	BuiltinOperator_DEPTHWISE_CONV_2D = `4`,
912	BuiltinOperator_DEPTH_TO_SPACE = `5`,
913	BuiltinOperator_DEQUANTIZE = `6`,
914	BuiltinOperator_EMBEDDING_LOOKUP = `7`,
915	BuiltinOperator_FLOOR = `8`,
916	BuiltinOperator_FULLY_CONNECTED = `9`,
917	BuiltinOperator_HASHTABLE_LOOKUP = `10`,
918	BuiltinOperator_L2_NORMALIZATION = `11`,
919	BuiltinOperator_L2_POOL_2D = `12`,
920	BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = `13`,
921	BuiltinOperator_LOGISTIC = `14`,
922	BuiltinOperator_LSH_PROJECTION = `15`,
923	BuiltinOperator_LSTM = `16`,
924	BuiltinOperator_MAX_POOL_2D = `17`,
925	BuiltinOperator_MUL = `18`,
926	BuiltinOperator_RELU = `19`,
927	BuiltinOperator_RELU_N1_TO_1 = `20`,
928	BuiltinOperator_RELU6 = `21`,
929	BuiltinOperator_RESHAPE = `22`,
930	BuiltinOperator_RESIZE_BILINEAR = `23`,
931	BuiltinOperator_RNN = `24`,
932	BuiltinOperator_SOFTMAX = `25`,
933	BuiltinOperator_SPACE_TO_DEPTH = `26`,
934	BuiltinOperator_SVDF = `27`,
935	BuiltinOperator_TANH = `28`,
936	BuiltinOperator_CONCAT_EMBEDDINGS = `29`,
937	BuiltinOperator_SKIP_GRAM = `30`,
938	BuiltinOperator_CALL = `31`,
939	BuiltinOperator_CUSTOM = `32`,
940	BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = `33`,
941	BuiltinOperator_PAD = `34`,
942	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = `35`,
943	BuiltinOperator_GATHER = `36`,
944	BuiltinOperator_BATCH_TO_SPACE_ND = `37`,
945	BuiltinOperator_SPACE_TO_BATCH_ND = `38`,
946	BuiltinOperator_TRANSPOSE = `39`,
947	BuiltinOperator_MEAN = `40`,
948	BuiltinOperator_SUB = `41`,
949	BuiltinOperator_DIV = `42`,
950	BuiltinOperator_SQUEEZE = `43`,
951	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = `44`,
952	BuiltinOperator_STRIDED_SLICE = `45`,
953	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = `46`,
954	BuiltinOperator_EXP = `47`,
955	BuiltinOperator_TOPK_V2 = `48`,
956	BuiltinOperator_SPLIT = `49`,
957	BuiltinOperator_LOG_SOFTMAX = `50`,
958	BuiltinOperator_DELEGATE = `51`,
959	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = `52`,
960	BuiltinOperator_CAST = `53`,
961	BuiltinOperator_PRELU = `54`,
962	BuiltinOperator_MAXIMUM = `55`,
963	BuiltinOperator_ARG_MAX = `56`,
964	BuiltinOperator_MINIMUM = `57`,
965	BuiltinOperator_LESS = `58`,
966	BuiltinOperator_NEG = `59`,
967	BuiltinOperator_PADV2 = `60`,
968	BuiltinOperator_GREATER = `61`,
969	BuiltinOperator_GREATER_EQUAL = `62`,
970	BuiltinOperator_LESS_EQUAL = `63`,
971	BuiltinOperator_SELECT = `64`,
972	BuiltinOperator_SLICE = `65`,
973	BuiltinOperator_SIN = `66`,
974	BuiltinOperator_TRANSPOSE_CONV = `67`,
975	BuiltinOperator_SPARSE_TO_DENSE = `68`,
976	BuiltinOperator_TILE = `69`,
977	BuiltinOperator_EXPAND_DIMS = `70`,
978	BuiltinOperator_EQUAL = `71`,
979	BuiltinOperator_NOT_EQUAL = `72`,
980	BuiltinOperator_LOG = `73`,
981	BuiltinOperator_SUM = `74`,
982	BuiltinOperator_SQRT = `75`,
983	BuiltinOperator_RSQRT = `76`,
984	BuiltinOperator_SHAPE = `77`,
985	BuiltinOperator_POW = `78`,
986	BuiltinOperator_ARG_MIN = `79`,
987	BuiltinOperator_FAKE_QUANT = `80`,
988	BuiltinOperator_REDUCE_PROD = `81`,
989	BuiltinOperator_REDUCE_MAX = `82`,
990	BuiltinOperator_PACK = `83`,
991	BuiltinOperator_LOGICAL_OR = `84`,
992	BuiltinOperator_ONE_HOT = `85`,
993	BuiltinOperator_LOGICAL_AND = `86`,
994	BuiltinOperator_LOGICAL_NOT = `87`,
995	BuiltinOperator_UNPACK = `88`,
996	BuiltinOperator_REDUCE_MIN = `89`,
997	BuiltinOperator_FLOOR_DIV = `90`,
998	BuiltinOperator_REDUCE_ANY = `91`,
999	BuiltinOperator_SQUARE = `92`,
1000	BuiltinOperator_ZEROS_LIKE = `93`,
1001	BuiltinOperator_FILL = `94`,
1002	BuiltinOperator_FLOOR_MOD = `95`,
1003	BuiltinOperator_RANGE = `96`,
1004	BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = `97`,
1005	BuiltinOperator_LEAKY_RELU = `98`,
1006	BuiltinOperator_SQUARED_DIFFERENCE = `99`,
1007	BuiltinOperator_MIRROR_PAD = `100`,
1008	BuiltinOperator_ABS = `101`,
1009	BuiltinOperator_SPLIT_V = `102`,
1010	BuiltinOperator_UNIQUE = `103`,
1011	BuiltinOperator_CEIL = `104`,
1012	BuiltinOperator_REVERSE_V2 = `105`,
1013	BuiltinOperator_ADD_N = `106`,
1014	BuiltinOperator_GATHER_ND = `107`,
1015	BuiltinOperator_COS = `108`,
1016	BuiltinOperator_WHERE = `109`,
1017	BuiltinOperator_RANK = `110`,
1018	BuiltinOperator_ELU = `111`,
1019	BuiltinOperator_REVERSE_SEQUENCE = `112`,
1020	BuiltinOperator_MATRIX_DIAG = `113`,
1021	BuiltinOperator_QUANTIZE = `114`,
1022	BuiltinOperator_MATRIX_SET_DIAG = `115`,
1023	BuiltinOperator_ROUND = `116`,
1024	BuiltinOperator_HARD_SWISH = `117`,
1025	BuiltinOperator_IF = `118`,
1026	BuiltinOperator_WHILE = `119`,
1027	BuiltinOperator_NON_MAX_SUPPRESSION_V4 = `120`,
1028	BuiltinOperator_NON_MAX_SUPPRESSION_V5 = `121`,
1029	BuiltinOperator_SCATTER_ND = `122`,
1030	BuiltinOperator_SELECT_V2 = `123`,
1031	BuiltinOperator_DENSIFY = `124`,
1032	BuiltinOperator_SEGMENT_SUM = `125`,
1033	BuiltinOperator_BATCH_MATMUL = `126`,
1034	BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES = `127`,
1035	BuiltinOperator_CUMSUM = `128`,
1036	BuiltinOperator_CALL_ONCE = `129`,
1037	BuiltinOperator_BROADCAST_TO = `130`,
1038	BuiltinOperator_RFFT2D = `131`,
1039	BuiltinOperator_CONV_3D = `132`,
1040	BuiltinOperator_IMAG = `133`,
1041	BuiltinOperator_REAL = `134`,
1042	BuiltinOperator_COMPLEX_ABS = `135`,
1043	BuiltinOperator_HASHTABLE = `136`,
1044	BuiltinOperator_HASHTABLE_FIND = `137`,
1045	BuiltinOperator_HASHTABLE_IMPORT = `138`,
1046	BuiltinOperator_HASHTABLE_SIZE = `139`,
1047	BuiltinOperator_REDUCE_ALL = `140`,
1048	BuiltinOperator_CONV_3D_TRANSPOSE = `141`,
1049	BuiltinOperator_VAR_HANDLE = `142`,
1050	BuiltinOperator_READ_VARIABLE = `143`,
1051	BuiltinOperator_ASSIGN_VARIABLE = `144`,
1052	BuiltinOperator_BROADCAST_ARGS = `145`,
1053	BuiltinOperator_RANDOM_STANDARD_NORMAL = `146`,
1054	BuiltinOperator_BUCKETIZE = `147`,
1055	BuiltinOperator_RANDOM_UNIFORM = `148`,
1056	BuiltinOperator_MULTINOMIAL = `149`,
1057	BuiltinOperator_GELU = `150`,
1058	BuiltinOperator_DYNAMIC_UPDATE_SLICE = `151`,
1059	BuiltinOperator_RELU_0_TO_1 = `152`,
1060	BuiltinOperator_UNSORTED_SEGMENT_PROD = `153`,
1061	BuiltinOperator_UNSORTED_SEGMENT_MAX = `154`,
1062	BuiltinOperator_UNSORTED_SEGMENT_SUM = `155`,
1063	BuiltinOperator_ATAN2 = `156`,
1064	BuiltinOperator_UNSORTED_SEGMENT_MIN = `157`,
1065	BuiltinOperator_SIGN = `158`,
1066	BuiltinOperator_MIN = BuiltinOperator_ADD,
1067	BuiltinOperator_MAX = BuiltinOperator_SIGN
1068	};
1069
1070	inline const BuiltinOperator (&EnumValuesBuiltinOperator())[`159`] {
1071	static const BuiltinOperator values[] = {
1072	BuiltinOperator_ADD,
1073	BuiltinOperator_AVERAGE_POOL_2D,
1074	BuiltinOperator_CONCATENATION,
1075	BuiltinOperator_CONV_2D,
1076	BuiltinOperator_DEPTHWISE_CONV_2D,
1077	BuiltinOperator_DEPTH_TO_SPACE,
1078	BuiltinOperator_DEQUANTIZE,
1079	BuiltinOperator_EMBEDDING_LOOKUP,
1080	BuiltinOperator_FLOOR,
1081	BuiltinOperator_FULLY_CONNECTED,
1082	BuiltinOperator_HASHTABLE_LOOKUP,
1083	BuiltinOperator_L2_NORMALIZATION,
1084	BuiltinOperator_L2_POOL_2D,
1085	BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION,
1086	BuiltinOperator_LOGISTIC,
1087	BuiltinOperator_LSH_PROJECTION,
1088	BuiltinOperator_LSTM,
1089	BuiltinOperator_MAX_POOL_2D,
1090	BuiltinOperator_MUL,
1091	BuiltinOperator_RELU,
1092	BuiltinOperator_RELU_N1_TO_1,
1093	BuiltinOperator_RELU6,
1094	BuiltinOperator_RESHAPE,
1095	BuiltinOperator_RESIZE_BILINEAR,
1096	BuiltinOperator_RNN,
1097	BuiltinOperator_SOFTMAX,
1098	BuiltinOperator_SPACE_TO_DEPTH,
1099	BuiltinOperator_SVDF,
1100	BuiltinOperator_TANH,
1101	BuiltinOperator_CONCAT_EMBEDDINGS,
1102	BuiltinOperator_SKIP_GRAM,
1103	BuiltinOperator_CALL,
1104	BuiltinOperator_CUSTOM,
1105	BuiltinOperator_EMBEDDING_LOOKUP_SPARSE,
1106	BuiltinOperator_PAD,
1107	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN,
1108	BuiltinOperator_GATHER,
1109	BuiltinOperator_BATCH_TO_SPACE_ND,
1110	BuiltinOperator_SPACE_TO_BATCH_ND,
1111	BuiltinOperator_TRANSPOSE,
1112	BuiltinOperator_MEAN,
1113	BuiltinOperator_SUB,
1114	BuiltinOperator_DIV,
1115	BuiltinOperator_SQUEEZE,
1116	BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM,
1117	BuiltinOperator_STRIDED_SLICE,
1118	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN,
1119	BuiltinOperator_EXP,
1120	BuiltinOperator_TOPK_V2,
1121	BuiltinOperator_SPLIT,
1122	BuiltinOperator_LOG_SOFTMAX,
1123	BuiltinOperator_DELEGATE,
1124	BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM,
1125	BuiltinOperator_CAST,
1126	BuiltinOperator_PRELU,
1127	BuiltinOperator_MAXIMUM,
1128	BuiltinOperator_ARG_MAX,
1129	BuiltinOperator_MINIMUM,
1130	BuiltinOperator_LESS,
1131	BuiltinOperator_NEG,
1132	BuiltinOperator_PADV2,
1133	BuiltinOperator_GREATER,
1134	BuiltinOperator_GREATER_EQUAL,
1135	BuiltinOperator_LESS_EQUAL,
1136	BuiltinOperator_SELECT,
1137	BuiltinOperator_SLICE,
1138	BuiltinOperator_SIN,
1139	BuiltinOperator_TRANSPOSE_CONV,
1140	BuiltinOperator_SPARSE_TO_DENSE,
1141	BuiltinOperator_TILE,
1142	BuiltinOperator_EXPAND_DIMS,
1143	BuiltinOperator_EQUAL,
1144	BuiltinOperator_NOT_EQUAL,
1145	BuiltinOperator_LOG,
1146	BuiltinOperator_SUM,
1147	BuiltinOperator_SQRT,
1148	BuiltinOperator_RSQRT,
1149	BuiltinOperator_SHAPE,
1150	BuiltinOperator_POW,
1151	BuiltinOperator_ARG_MIN,
1152	BuiltinOperator_FAKE_QUANT,
1153	BuiltinOperator_REDUCE_PROD,
1154	BuiltinOperator_REDUCE_MAX,
1155	BuiltinOperator_PACK,
1156	BuiltinOperator_LOGICAL_OR,
1157	BuiltinOperator_ONE_HOT,
1158	BuiltinOperator_LOGICAL_AND,
1159	BuiltinOperator_LOGICAL_NOT,
1160	BuiltinOperator_UNPACK,
1161	BuiltinOperator_REDUCE_MIN,
1162	BuiltinOperator_FLOOR_DIV,
1163	BuiltinOperator_REDUCE_ANY,
1164	BuiltinOperator_SQUARE,
1165	BuiltinOperator_ZEROS_LIKE,
1166	BuiltinOperator_FILL,
1167	BuiltinOperator_FLOOR_MOD,
1168	BuiltinOperator_RANGE,
1169	BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
1170	BuiltinOperator_LEAKY_RELU,
1171	BuiltinOperator_SQUARED_DIFFERENCE,
1172	BuiltinOperator_MIRROR_PAD,
1173	BuiltinOperator_ABS,
1174	BuiltinOperator_SPLIT_V,
1175	BuiltinOperator_UNIQUE,
1176	BuiltinOperator_CEIL,
1177	BuiltinOperator_REVERSE_V2,
1178	BuiltinOperator_ADD_N,
1179	BuiltinOperator_GATHER_ND,
1180	BuiltinOperator_COS,
1181	BuiltinOperator_WHERE,
1182	BuiltinOperator_RANK,
1183	BuiltinOperator_ELU,
1184	BuiltinOperator_REVERSE_SEQUENCE,
1185	BuiltinOperator_MATRIX_DIAG,
1186	BuiltinOperator_QUANTIZE,
1187	BuiltinOperator_MATRIX_SET_DIAG,
1188	BuiltinOperator_ROUND,
1189	BuiltinOperator_HARD_SWISH,
1190	BuiltinOperator_IF,
1191	BuiltinOperator_WHILE,
1192	BuiltinOperator_NON_MAX_SUPPRESSION_V4,
1193	BuiltinOperator_NON_MAX_SUPPRESSION_V5,
1194	BuiltinOperator_SCATTER_ND,
1195	BuiltinOperator_SELECT_V2,
1196	BuiltinOperator_DENSIFY,
1197	BuiltinOperator_SEGMENT_SUM,
1198	BuiltinOperator_BATCH_MATMUL,
1199	BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES,
1200	BuiltinOperator_CUMSUM,
1201	BuiltinOperator_CALL_ONCE,
1202	BuiltinOperator_BROADCAST_TO,
1203	BuiltinOperator_RFFT2D,
1204	BuiltinOperator_CONV_3D,
1205	BuiltinOperator_IMAG,
1206	BuiltinOperator_REAL,
1207	BuiltinOperator_COMPLEX_ABS,
1208	BuiltinOperator_HASHTABLE,
1209	BuiltinOperator_HASHTABLE_FIND,
1210	BuiltinOperator_HASHTABLE_IMPORT,
1211	BuiltinOperator_HASHTABLE_SIZE,
1212	BuiltinOperator_REDUCE_ALL,
1213	BuiltinOperator_CONV_3D_TRANSPOSE,
1214	BuiltinOperator_VAR_HANDLE,
1215	BuiltinOperator_READ_VARIABLE,
1216	BuiltinOperator_ASSIGN_VARIABLE,
1217	BuiltinOperator_BROADCAST_ARGS,
1218	BuiltinOperator_RANDOM_STANDARD_NORMAL,
1219	BuiltinOperator_BUCKETIZE,
1220	BuiltinOperator_RANDOM_UNIFORM,
1221	BuiltinOperator_MULTINOMIAL,
1222	BuiltinOperator_GELU,
1223	BuiltinOperator_DYNAMIC_UPDATE_SLICE,
1224	BuiltinOperator_RELU_0_TO_1,
1225	BuiltinOperator_UNSORTED_SEGMENT_PROD,
1226	BuiltinOperator_UNSORTED_SEGMENT_MAX,
1227	BuiltinOperator_UNSORTED_SEGMENT_SUM,
1228	BuiltinOperator_ATAN2,
1229	BuiltinOperator_UNSORTED_SEGMENT_MIN,
1230	BuiltinOperator_SIGN
1231	};
1232	return values;
1233	}
1234
1235	inline const char * const *EnumNamesBuiltinOperator() {
1236	static const char * const names[`160`] = {
1237	"ADD",
1238	"AVERAGE_POOL_2D",
1239	"CONCATENATION",
1240	"CONV_2D",
1241	"DEPTHWISE_CONV_2D",
1242	"DEPTH_TO_SPACE",
1243	"DEQUANTIZE",
1244	"EMBEDDING_LOOKUP",
1245	"FLOOR",
1246	"FULLY_CONNECTED",
1247	"HASHTABLE_LOOKUP",
1248	"L2_NORMALIZATION",
1249	"L2_POOL_2D",
1250	"LOCAL_RESPONSE_NORMALIZATION",
1251	"LOGISTIC",
1252	"LSH_PROJECTION",
1253	"LSTM",
1254	"MAX_POOL_2D",
1255	"MUL",
1256	"RELU",
1257	"RELU_N1_TO_1",
1258	"RELU6",
1259	"RESHAPE",
1260	"RESIZE_BILINEAR",
1261	"RNN",
1262	"SOFTMAX",
1263	"SPACE_TO_DEPTH",
1264	"SVDF",
1265	"TANH",
1266	"CONCAT_EMBEDDINGS",
1267	"SKIP_GRAM",
1268	"CALL",
1269	"CUSTOM",
1270	"EMBEDDING_LOOKUP_SPARSE",
1271	"PAD",
1272	"UNIDIRECTIONAL_SEQUENCE_RNN",
1273	"GATHER",
1274	"BATCH_TO_SPACE_ND",
1275	"SPACE_TO_BATCH_ND",
1276	"TRANSPOSE",
1277	"MEAN",
1278	"SUB",
1279	"DIV",
1280	"SQUEEZE",
1281	"UNIDIRECTIONAL_SEQUENCE_LSTM",
1282	"STRIDED_SLICE",
1283	"BIDIRECTIONAL_SEQUENCE_RNN",
1284	"EXP",
1285	"TOPK_V2",
1286	"SPLIT",
1287	"LOG_SOFTMAX",
1288	"DELEGATE",
1289	"BIDIRECTIONAL_SEQUENCE_LSTM",
1290	"CAST",
1291	"PRELU",
1292	"MAXIMUM",
1293	"ARG_MAX",
1294	"MINIMUM",
1295	"LESS",
1296	"NEG",
1297	"PADV2",
1298	"GREATER",
1299	"GREATER_EQUAL",
1300	"LESS_EQUAL",
1301	"SELECT",
1302	"SLICE",
1303	"SIN",
1304	"TRANSPOSE_CONV",
1305	"SPARSE_TO_DENSE",
1306	"TILE",
1307	"EXPAND_DIMS",
1308	"EQUAL",
1309	"NOT_EQUAL",
1310	"LOG",
1311	"SUM",
1312	"SQRT",
1313	"RSQRT",
1314	"SHAPE",
1315	"POW",
1316	"ARG_MIN",
1317	"FAKE_QUANT",
1318	"REDUCE_PROD",
1319	"REDUCE_MAX",
1320	"PACK",
1321	"LOGICAL_OR",
1322	"ONE_HOT",
1323	"LOGICAL_AND",
1324	"LOGICAL_NOT",
1325	"UNPACK",
1326	"REDUCE_MIN",
1327	"FLOOR_DIV",
1328	"REDUCE_ANY",
1329	"SQUARE",
1330	"ZEROS_LIKE",
1331	"FILL",
1332	"FLOOR_MOD",
1333	"RANGE",
1334	"RESIZE_NEAREST_NEIGHBOR",
1335	"LEAKY_RELU",
1336	"SQUARED_DIFFERENCE",
1337	"MIRROR_PAD",
1338	"ABS",
1339	"SPLIT_V",
1340	"UNIQUE",
1341	"CEIL",
1342	"REVERSE_V2",
1343	"ADD_N",
1344	"GATHER_ND",
1345	"COS",
1346	"WHERE",
1347	"RANK",
1348	"ELU",
1349	"REVERSE_SEQUENCE",
1350	"MATRIX_DIAG",
1351	"QUANTIZE",
1352	"MATRIX_SET_DIAG",
1353	"ROUND",
1354	"HARD_SWISH",
1355	"IF",
1356	"WHILE",
1357	"NON_MAX_SUPPRESSION_V4",
1358	"NON_MAX_SUPPRESSION_V5",
1359	"SCATTER_ND",
1360	"SELECT_V2",
1361	"DENSIFY",
1362	"SEGMENT_SUM",
1363	"BATCH_MATMUL",
1364	"PLACEHOLDER_FOR_GREATER_OP_CODES",
1365	"CUMSUM",
1366	"CALL_ONCE",
1367	"BROADCAST_TO",
1368	"RFFT2D",
1369	"CONV_3D",
1370	"IMAG",
1371	"REAL",
1372	"COMPLEX_ABS",
1373	"HASHTABLE",
1374	"HASHTABLE_FIND",
1375	"HASHTABLE_IMPORT",
1376	"HASHTABLE_SIZE",
1377	"REDUCE_ALL",
1378	"CONV_3D_TRANSPOSE",
1379	"VAR_HANDLE",
1380	"READ_VARIABLE",
1381	"ASSIGN_VARIABLE",
1382	"BROADCAST_ARGS",
1383	"RANDOM_STANDARD_NORMAL",
1384	"BUCKETIZE",
1385	"RANDOM_UNIFORM",
1386	"MULTINOMIAL",
1387	"GELU",
1388	"DYNAMIC_UPDATE_SLICE",
1389	"RELU_0_TO_1",
1390	"UNSORTED_SEGMENT_PROD",
1391	"UNSORTED_SEGMENT_MAX",
1392	"UNSORTED_SEGMENT_SUM",
1393	"ATAN2",
1394	"UNSORTED_SEGMENT_MIN",
1395	"SIGN",
1396	nullptr
1397	};
1398	return names;
1399	}
1400
1401	inline const char *EnumNameBuiltinOperator(BuiltinOperator e) {
1402	if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_SIGN)) return "";
1403	const size_t index = static_cast<size_t>(e);
1404	return EnumNamesBuiltinOperator()[index];
1405	}
1406
1407	enum BuiltinOptions : uint8_t {
1408	BuiltinOptions_NONE = `0`,
1409	BuiltinOptions_Conv2DOptions = `1`,
1410	BuiltinOptions_DepthwiseConv2DOptions = `2`,
1411	BuiltinOptions_ConcatEmbeddingsOptions = `3`,
1412	BuiltinOptions_LSHProjectionOptions = `4`,
1413	BuiltinOptions_Pool2DOptions = `5`,
1414	BuiltinOptions_SVDFOptions = `6`,
1415	BuiltinOptions_RNNOptions = `7`,
1416	BuiltinOptions_FullyConnectedOptions = `8`,
1417	BuiltinOptions_SoftmaxOptions = `9`,
1418	BuiltinOptions_ConcatenationOptions = `10`,
1419	BuiltinOptions_AddOptions = `11`,
1420	BuiltinOptions_L2NormOptions = `12`,
1421	BuiltinOptions_LocalResponseNormalizationOptions = `13`,
1422	BuiltinOptions_LSTMOptions = `14`,
1423	BuiltinOptions_ResizeBilinearOptions = `15`,
1424	BuiltinOptions_CallOptions = `16`,
1425	BuiltinOptions_ReshapeOptions = `17`,
1426	BuiltinOptions_SkipGramOptions = `18`,
1427	BuiltinOptions_SpaceToDepthOptions = `19`,
1428	BuiltinOptions_EmbeddingLookupSparseOptions = `20`,
1429	BuiltinOptions_MulOptions = `21`,
1430	BuiltinOptions_PadOptions = `22`,
1431	BuiltinOptions_GatherOptions = `23`,
1432	BuiltinOptions_BatchToSpaceNDOptions = `24`,
1433	BuiltinOptions_SpaceToBatchNDOptions = `25`,
1434	BuiltinOptions_TransposeOptions = `26`,
1435	BuiltinOptions_ReducerOptions = `27`,
1436	BuiltinOptions_SubOptions = `28`,
1437	BuiltinOptions_DivOptions = `29`,
1438	BuiltinOptions_SqueezeOptions = `30`,
1439	BuiltinOptions_SequenceRNNOptions = `31`,
1440	BuiltinOptions_StridedSliceOptions = `32`,
1441	BuiltinOptions_ExpOptions = `33`,
1442	BuiltinOptions_TopKV2Options = `34`,
1443	BuiltinOptions_SplitOptions = `35`,
1444	BuiltinOptions_LogSoftmaxOptions = `36`,
1445	BuiltinOptions_CastOptions = `37`,
1446	BuiltinOptions_DequantizeOptions = `38`,
1447	BuiltinOptions_MaximumMinimumOptions = `39`,
1448	BuiltinOptions_ArgMaxOptions = `40`,
1449	BuiltinOptions_LessOptions = `41`,
1450	BuiltinOptions_NegOptions = `42`,
1451	BuiltinOptions_PadV2Options = `43`,
1452	BuiltinOptions_GreaterOptions = `44`,
1453	BuiltinOptions_GreaterEqualOptions = `45`,
1454	BuiltinOptions_LessEqualOptions = `46`,
1455	BuiltinOptions_SelectOptions = `47`,
1456	BuiltinOptions_SliceOptions = `48`,
1457	BuiltinOptions_TransposeConvOptions = `49`,
1458	BuiltinOptions_SparseToDenseOptions = `50`,
1459	BuiltinOptions_TileOptions = `51`,
1460	BuiltinOptions_ExpandDimsOptions = `52`,
1461	BuiltinOptions_EqualOptions = `53`,
1462	BuiltinOptions_NotEqualOptions = `54`,
1463	BuiltinOptions_ShapeOptions = `55`,
1464	BuiltinOptions_PowOptions = `56`,
1465	BuiltinOptions_ArgMinOptions = `57`,
1466	BuiltinOptions_FakeQuantOptions = `58`,
1467	BuiltinOptions_PackOptions = `59`,
1468	BuiltinOptions_LogicalOrOptions = `60`,
1469	BuiltinOptions_OneHotOptions = `61`,
1470	BuiltinOptions_LogicalAndOptions = `62`,
1471	BuiltinOptions_LogicalNotOptions = `63`,
1472	BuiltinOptions_UnpackOptions = `64`,
1473	BuiltinOptions_FloorDivOptions = `65`,
1474	BuiltinOptions_SquareOptions = `66`,
1475	BuiltinOptions_ZerosLikeOptions = `67`,
1476	BuiltinOptions_FillOptions = `68`,
1477	BuiltinOptions_BidirectionalSequenceLSTMOptions = `69`,
1478	BuiltinOptions_BidirectionalSequenceRNNOptions = `70`,
1479	BuiltinOptions_UnidirectionalSequenceLSTMOptions = `71`,
1480	BuiltinOptions_FloorModOptions = `72`,
1481	BuiltinOptions_RangeOptions = `73`,
1482	BuiltinOptions_ResizeNearestNeighborOptions = `74`,
1483	BuiltinOptions_LeakyReluOptions = `75`,
1484	BuiltinOptions_SquaredDifferenceOptions = `76`,
1485	BuiltinOptions_MirrorPadOptions = `77`,
1486	BuiltinOptions_AbsOptions = `78`,
1487	BuiltinOptions_SplitVOptions = `79`,
1488	BuiltinOptions_UniqueOptions = `80`,
1489	BuiltinOptions_ReverseV2Options = `81`,
1490	BuiltinOptions_AddNOptions = `82`,
1491	BuiltinOptions_GatherNdOptions = `83`,
1492	BuiltinOptions_CosOptions = `84`,
1493	BuiltinOptions_WhereOptions = `85`,
1494	BuiltinOptions_RankOptions = `86`,
1495	BuiltinOptions_ReverseSequenceOptions = `87`,
1496	BuiltinOptions_MatrixDiagOptions = `88`,
1497	BuiltinOptions_QuantizeOptions = `89`,
1498	BuiltinOptions_MatrixSetDiagOptions = `90`,
1499	BuiltinOptions_HardSwishOptions = `91`,
1500	BuiltinOptions_IfOptions = `92`,
1501	BuiltinOptions_WhileOptions = `93`,
1502	BuiltinOptions_DepthToSpaceOptions = `94`,
1503	BuiltinOptions_NonMaxSuppressionV4Options = `95`,
1504	BuiltinOptions_NonMaxSuppressionV5Options = `96`,
1505	BuiltinOptions_ScatterNdOptions = `97`,
1506	BuiltinOptions_SelectV2Options = `98`,
1507	BuiltinOptions_DensifyOptions = `99`,
1508	BuiltinOptions_SegmentSumOptions = `100`,
1509	BuiltinOptions_BatchMatMulOptions = `101`,
1510	BuiltinOptions_CumsumOptions = `102`,
1511	BuiltinOptions_CallOnceOptions = `103`,
1512	BuiltinOptions_BroadcastToOptions = `104`,
1513	BuiltinOptions_Rfft2dOptions = `105`,
1514	BuiltinOptions_Conv3DOptions = `106`,
1515	BuiltinOptions_HashtableOptions = `107`,
1516	BuiltinOptions_HashtableFindOptions = `108`,
1517	BuiltinOptions_HashtableImportOptions = `109`,
1518	BuiltinOptions_HashtableSizeOptions = `110`,
1519	BuiltinOptions_VarHandleOptions = `111`,
1520	BuiltinOptions_ReadVariableOptions = `112`,
1521	BuiltinOptions_AssignVariableOptions = `113`,
1522	BuiltinOptions_RandomOptions = `114`,
1523	BuiltinOptions_BucketizeOptions = `115`,
1524	BuiltinOptions_GeluOptions = `116`,
1525	BuiltinOptions_DynamicUpdateSliceOptions = `117`,
1526	BuiltinOptions_UnsortedSegmentProdOptions = `118`,
1527	BuiltinOptions_UnsortedSegmentMaxOptions = `119`,
1528	BuiltinOptions_UnsortedSegmentMinOptions = `120`,
1529	BuiltinOptions_UnsortedSegmentSumOptions = `121`,
1530	BuiltinOptions_ATan2Options = `122`,
1531	BuiltinOptions_SignOptions = `123`,
1532	BuiltinOptions_MIN = BuiltinOptions_NONE,
1533	BuiltinOptions_MAX = BuiltinOptions_SignOptions
1534	};
1535
1536	inline const BuiltinOptions (&EnumValuesBuiltinOptions())[`124`] {
1537	static const BuiltinOptions values[] = {
1538	BuiltinOptions_NONE,
1539	BuiltinOptions_Conv2DOptions,
1540	BuiltinOptions_DepthwiseConv2DOptions,
1541	BuiltinOptions_ConcatEmbeddingsOptions,
1542	BuiltinOptions_LSHProjectionOptions,
1543	BuiltinOptions_Pool2DOptions,
1544	BuiltinOptions_SVDFOptions,
1545	BuiltinOptions_RNNOptions,
1546	BuiltinOptions_FullyConnectedOptions,
1547	BuiltinOptions_SoftmaxOptions,
1548	BuiltinOptions_ConcatenationOptions,
1549	BuiltinOptions_AddOptions,
1550	BuiltinOptions_L2NormOptions,
1551	BuiltinOptions_LocalResponseNormalizationOptions,
1552	BuiltinOptions_LSTMOptions,
1553	BuiltinOptions_ResizeBilinearOptions,
1554	BuiltinOptions_CallOptions,
1555	BuiltinOptions_ReshapeOptions,
1556	BuiltinOptions_SkipGramOptions,
1557	BuiltinOptions_SpaceToDepthOptions,
1558	BuiltinOptions_EmbeddingLookupSparseOptions,
1559	BuiltinOptions_MulOptions,
1560	BuiltinOptions_PadOptions,
1561	BuiltinOptions_GatherOptions,
1562	BuiltinOptions_BatchToSpaceNDOptions,
1563	BuiltinOptions_SpaceToBatchNDOptions,
1564	BuiltinOptions_TransposeOptions,
1565	BuiltinOptions_ReducerOptions,
1566	BuiltinOptions_SubOptions,
1567	BuiltinOptions_DivOptions,
1568	BuiltinOptions_SqueezeOptions,
1569	BuiltinOptions_SequenceRNNOptions,
1570	BuiltinOptions_StridedSliceOptions,
1571	BuiltinOptions_ExpOptions,
1572	BuiltinOptions_TopKV2Options,
1573	BuiltinOptions_SplitOptions,
1574	BuiltinOptions_LogSoftmaxOptions,
1575	BuiltinOptions_CastOptions,
1576	BuiltinOptions_DequantizeOptions,
1577	BuiltinOptions_MaximumMinimumOptions,
1578	BuiltinOptions_ArgMaxOptions,
1579	BuiltinOptions_LessOptions,
1580	BuiltinOptions_NegOptions,
1581	BuiltinOptions_PadV2Options,
1582	BuiltinOptions_GreaterOptions,
1583	BuiltinOptions_GreaterEqualOptions,
1584	BuiltinOptions_LessEqualOptions,
1585	BuiltinOptions_SelectOptions,
1586	BuiltinOptions_SliceOptions,
1587	BuiltinOptions_TransposeConvOptions,
1588	BuiltinOptions_SparseToDenseOptions,
1589	BuiltinOptions_TileOptions,
1590	BuiltinOptions_ExpandDimsOptions,
1591	BuiltinOptions_EqualOptions,
1592	BuiltinOptions_NotEqualOptions,
1593	BuiltinOptions_ShapeOptions,
1594	BuiltinOptions_PowOptions,
1595	BuiltinOptions_ArgMinOptions,
1596	BuiltinOptions_FakeQuantOptions,
1597	BuiltinOptions_PackOptions,
1598	BuiltinOptions_LogicalOrOptions,
1599	BuiltinOptions_OneHotOptions,
1600	BuiltinOptions_LogicalAndOptions,
1601	BuiltinOptions_LogicalNotOptions,
1602	BuiltinOptions_UnpackOptions,
1603	BuiltinOptions_FloorDivOptions,
1604	BuiltinOptions_SquareOptions,
1605	BuiltinOptions_ZerosLikeOptions,
1606	BuiltinOptions_FillOptions,
1607	BuiltinOptions_BidirectionalSequenceLSTMOptions,
1608	BuiltinOptions_BidirectionalSequenceRNNOptions,
1609	BuiltinOptions_UnidirectionalSequenceLSTMOptions,
1610	BuiltinOptions_FloorModOptions,
1611	BuiltinOptions_RangeOptions,
1612	BuiltinOptions_ResizeNearestNeighborOptions,
1613	BuiltinOptions_LeakyReluOptions,
1614	BuiltinOptions_SquaredDifferenceOptions,
1615	BuiltinOptions_MirrorPadOptions,
1616	BuiltinOptions_AbsOptions,
1617	BuiltinOptions_SplitVOptions,
1618	BuiltinOptions_UniqueOptions,
1619	BuiltinOptions_ReverseV2Options,
1620	BuiltinOptions_AddNOptions,
1621	BuiltinOptions_GatherNdOptions,
1622	BuiltinOptions_CosOptions,
1623	BuiltinOptions_WhereOptions,
1624	BuiltinOptions_RankOptions,
1625	BuiltinOptions_ReverseSequenceOptions,
1626	BuiltinOptions_MatrixDiagOptions,
1627	BuiltinOptions_QuantizeOptions,
1628	BuiltinOptions_MatrixSetDiagOptions,
1629	BuiltinOptions_HardSwishOptions,
1630	BuiltinOptions_IfOptions,
1631	BuiltinOptions_WhileOptions,
1632	BuiltinOptions_DepthToSpaceOptions,
1633	BuiltinOptions_NonMaxSuppressionV4Options,
1634	BuiltinOptions_NonMaxSuppressionV5Options,
1635	BuiltinOptions_ScatterNdOptions,
1636	BuiltinOptions_SelectV2Options,
1637	BuiltinOptions_DensifyOptions,
1638	BuiltinOptions_SegmentSumOptions,
1639	BuiltinOptions_BatchMatMulOptions,
1640	BuiltinOptions_CumsumOptions,
1641	BuiltinOptions_CallOnceOptions,
1642	BuiltinOptions_BroadcastToOptions,
1643	BuiltinOptions_Rfft2dOptions,
1644	BuiltinOptions_Conv3DOptions,
1645	BuiltinOptions_HashtableOptions,
1646	BuiltinOptions_HashtableFindOptions,
1647	BuiltinOptions_HashtableImportOptions,
1648	BuiltinOptions_HashtableSizeOptions,
1649	BuiltinOptions_VarHandleOptions,
1650	BuiltinOptions_ReadVariableOptions,
1651	BuiltinOptions_AssignVariableOptions,
1652	BuiltinOptions_RandomOptions,
1653	BuiltinOptions_BucketizeOptions,
1654	BuiltinOptions_GeluOptions,
1655	BuiltinOptions_DynamicUpdateSliceOptions,
1656	BuiltinOptions_UnsortedSegmentProdOptions,
1657	BuiltinOptions_UnsortedSegmentMaxOptions,
1658	BuiltinOptions_UnsortedSegmentMinOptions,
1659	BuiltinOptions_UnsortedSegmentSumOptions,
1660	BuiltinOptions_ATan2Options,
1661	BuiltinOptions_SignOptions
1662	};
1663	return values;
1664	}
1665
1666	inline const char * const *EnumNamesBuiltinOptions() {
1667	static const char * const names[`125`] = {
1668	"NONE",
1669	"Conv2DOptions",
1670	"DepthwiseConv2DOptions",
1671	"ConcatEmbeddingsOptions",
1672	"LSHProjectionOptions",
1673	"Pool2DOptions",
1674	"SVDFOptions",
1675	"RNNOptions",
1676	"FullyConnectedOptions",
1677	"SoftmaxOptions",
1678	"ConcatenationOptions",
1679	"AddOptions",
1680	"L2NormOptions",
1681	"LocalResponseNormalizationOptions",
1682	"LSTMOptions",
1683	"ResizeBilinearOptions",
1684	"CallOptions",
1685	"ReshapeOptions",
1686	"SkipGramOptions",
1687	"SpaceToDepthOptions",
1688	"EmbeddingLookupSparseOptions",
1689	"MulOptions",
1690	"PadOptions",
1691	"GatherOptions",
1692	"BatchToSpaceNDOptions",
1693	"SpaceToBatchNDOptions",
1694	"TransposeOptions",
1695	"ReducerOptions",
1696	"SubOptions",
1697	"DivOptions",
1698	"SqueezeOptions",
1699	"SequenceRNNOptions",
1700	"StridedSliceOptions",
1701	"ExpOptions",
1702	"TopKV2Options",
1703	"SplitOptions",
1704	"LogSoftmaxOptions",
1705	"CastOptions",
1706	"DequantizeOptions",
1707	"MaximumMinimumOptions",
1708	"ArgMaxOptions",
1709	"LessOptions",
1710	"NegOptions",
1711	"PadV2Options",
1712	"GreaterOptions",
1713	"GreaterEqualOptions",
1714	"LessEqualOptions",
1715	"SelectOptions",
1716	"SliceOptions",
1717	"TransposeConvOptions",
1718	"SparseToDenseOptions",
1719	"TileOptions",
1720	"ExpandDimsOptions",
1721	"EqualOptions",
1722	"NotEqualOptions",
1723	"ShapeOptions",
1724	"PowOptions",
1725	"ArgMinOptions",
1726	"FakeQuantOptions",
1727	"PackOptions",
1728	"LogicalOrOptions",
1729	"OneHotOptions",
1730	"LogicalAndOptions",
1731	"LogicalNotOptions",
1732	"UnpackOptions",
1733	"FloorDivOptions",
1734	"SquareOptions",
1735	"ZerosLikeOptions",
1736	"FillOptions",
1737	"BidirectionalSequenceLSTMOptions",
1738	"BidirectionalSequenceRNNOptions",
1739	"UnidirectionalSequenceLSTMOptions",
1740	"FloorModOptions",
1741	"RangeOptions",
1742	"ResizeNearestNeighborOptions",
1743	"LeakyReluOptions",
1744	"SquaredDifferenceOptions",
1745	"MirrorPadOptions",
1746	"AbsOptions",
1747	"SplitVOptions",
1748	"UniqueOptions",
1749	"ReverseV2Options",
1750	"AddNOptions",
1751	"GatherNdOptions",
1752	"CosOptions",
1753	"WhereOptions",
1754	"RankOptions",
1755	"ReverseSequenceOptions",
1756	"MatrixDiagOptions",
1757	"QuantizeOptions",
1758	"MatrixSetDiagOptions",
1759	"HardSwishOptions",
1760	"IfOptions",
1761	"WhileOptions",
1762	"DepthToSpaceOptions",
1763	"NonMaxSuppressionV4Options",
1764	"NonMaxSuppressionV5Options",
1765	"ScatterNdOptions",
1766	"SelectV2Options",
1767	"DensifyOptions",
1768	"SegmentSumOptions",
1769	"BatchMatMulOptions",
1770	"CumsumOptions",
1771	"CallOnceOptions",
1772	"BroadcastToOptions",
1773	"Rfft2dOptions",
1774	"Conv3DOptions",
1775	"HashtableOptions",
1776	"HashtableFindOptions",
1777	"HashtableImportOptions",
1778	"HashtableSizeOptions",
1779	"VarHandleOptions",
1780	"ReadVariableOptions",
1781	"AssignVariableOptions",
1782	"RandomOptions",
1783	"BucketizeOptions",
1784	"GeluOptions",
1785	"DynamicUpdateSliceOptions",
1786	"UnsortedSegmentProdOptions",
1787	"UnsortedSegmentMaxOptions",
1788	"UnsortedSegmentMinOptions",
1789	"UnsortedSegmentSumOptions",
1790	"ATan2Options",
1791	"SignOptions",
1792	nullptr
1793	};
1794	return names;
1795	}
1796
1797	inline const char *EnumNameBuiltinOptions(BuiltinOptions e) {
1798	if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_SignOptions)) return "";
1799	const size_t index = static_cast<size_t>(e);
1800	return EnumNamesBuiltinOptions()[index];
1801	}
1802
1803	template<typename T> struct BuiltinOptionsTraits {
1804	static const BuiltinOptions enum_value = BuiltinOptions_NONE;
1805	};
1806
1807	template<> struct BuiltinOptionsTraits<tflite::Conv2DOptions> {
1808	static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
1809	};
1810
1811	template<> struct BuiltinOptionsTraits<tflite::DepthwiseConv2DOptions> {
1812	static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
1813	};
1814
1815	template<> struct BuiltinOptionsTraits<tflite::ConcatEmbeddingsOptions> {
1816	static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
1817	};
1818
1819	template<> struct BuiltinOptionsTraits<tflite::LSHProjectionOptions> {
1820	static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
1821	};
1822
1823	template<> struct BuiltinOptionsTraits<tflite::Pool2DOptions> {
1824	static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
1825	};
1826
1827	template<> struct BuiltinOptionsTraits<tflite::SVDFOptions> {
1828	static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
1829	};
1830
1831	template<> struct BuiltinOptionsTraits<tflite::RNNOptions> {
1832	static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
1833	};
1834
1835	template<> struct BuiltinOptionsTraits<tflite::FullyConnectedOptions> {
1836	static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
1837	};
1838
1839	template<> struct BuiltinOptionsTraits<tflite::SoftmaxOptions> {
1840	static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
1841	};
1842
1843	template<> struct BuiltinOptionsTraits<tflite::ConcatenationOptions> {
1844	static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
1845	};
1846
1847	template<> struct BuiltinOptionsTraits<tflite::AddOptions> {
1848	static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
1849	};
1850
1851	template<> struct BuiltinOptionsTraits<tflite::L2NormOptions> {
1852	static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
1853	};
1854
1855	template<> struct BuiltinOptionsTraits<tflite::LocalResponseNormalizationOptions> {
1856	static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
1857	};
1858
1859	template<> struct BuiltinOptionsTraits<tflite::LSTMOptions> {
1860	static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
1861	};
1862
1863	template<> struct BuiltinOptionsTraits<tflite::ResizeBilinearOptions> {
1864	static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
1865	};
1866
1867	template<> struct BuiltinOptionsTraits<tflite::CallOptions> {
1868	static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
1869	};
1870
1871	template<> struct BuiltinOptionsTraits<tflite::ReshapeOptions> {
1872	static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
1873	};
1874
1875	template<> struct BuiltinOptionsTraits<tflite::SkipGramOptions> {
1876	static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
1877	};
1878
1879	template<> struct BuiltinOptionsTraits<tflite::SpaceToDepthOptions> {
1880	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
1881	};
1882
1883	template<> struct BuiltinOptionsTraits<tflite::EmbeddingLookupSparseOptions> {
1884	static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
1885	};
1886
1887	template<> struct BuiltinOptionsTraits<tflite::MulOptions> {
1888	static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
1889	};
1890
1891	template<> struct BuiltinOptionsTraits<tflite::PadOptions> {
1892	static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
1893	};
1894
1895	template<> struct BuiltinOptionsTraits<tflite::GatherOptions> {
1896	static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
1897	};
1898
1899	template<> struct BuiltinOptionsTraits<tflite::BatchToSpaceNDOptions> {
1900	static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
1901	};
1902
1903	template<> struct BuiltinOptionsTraits<tflite::SpaceToBatchNDOptions> {
1904	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
1905	};
1906
1907	template<> struct BuiltinOptionsTraits<tflite::TransposeOptions> {
1908	static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
1909	};
1910
1911	template<> struct BuiltinOptionsTraits<tflite::ReducerOptions> {
1912	static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
1913	};
1914
1915	template<> struct BuiltinOptionsTraits<tflite::SubOptions> {
1916	static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
1917	};
1918
1919	template<> struct BuiltinOptionsTraits<tflite::DivOptions> {
1920	static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
1921	};
1922
1923	template<> struct BuiltinOptionsTraits<tflite::SqueezeOptions> {
1924	static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
1925	};
1926
1927	template<> struct BuiltinOptionsTraits<tflite::SequenceRNNOptions> {
1928	static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
1929	};
1930
1931	template<> struct BuiltinOptionsTraits<tflite::StridedSliceOptions> {
1932	static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
1933	};
1934
1935	template<> struct BuiltinOptionsTraits<tflite::ExpOptions> {
1936	static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
1937	};
1938
1939	template<> struct BuiltinOptionsTraits<tflite::TopKV2Options> {
1940	static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
1941	};
1942
1943	template<> struct BuiltinOptionsTraits<tflite::SplitOptions> {
1944	static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
1945	};
1946
1947	template<> struct BuiltinOptionsTraits<tflite::LogSoftmaxOptions> {
1948	static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
1949	};
1950
1951	template<> struct BuiltinOptionsTraits<tflite::CastOptions> {
1952	static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
1953	};
1954
1955	template<> struct BuiltinOptionsTraits<tflite::DequantizeOptions> {
1956	static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
1957	};
1958
1959	template<> struct BuiltinOptionsTraits<tflite::MaximumMinimumOptions> {
1960	static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
1961	};
1962
1963	template<> struct BuiltinOptionsTraits<tflite::ArgMaxOptions> {
1964	static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
1965	};
1966
1967	template<> struct BuiltinOptionsTraits<tflite::LessOptions> {
1968	static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
1969	};
1970
1971	template<> struct BuiltinOptionsTraits<tflite::NegOptions> {
1972	static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
1973	};
1974
1975	template<> struct BuiltinOptionsTraits<tflite::PadV2Options> {
1976	static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
1977	};
1978
1979	template<> struct BuiltinOptionsTraits<tflite::GreaterOptions> {
1980	static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
1981	};
1982
1983	template<> struct BuiltinOptionsTraits<tflite::GreaterEqualOptions> {
1984	static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
1985	};
1986
1987	template<> struct BuiltinOptionsTraits<tflite::LessEqualOptions> {
1988	static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
1989	};
1990
1991	template<> struct BuiltinOptionsTraits<tflite::SelectOptions> {
1992	static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
1993	};
1994
1995	template<> struct BuiltinOptionsTraits<tflite::SliceOptions> {
1996	static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
1997	};
1998
1999	template<> struct BuiltinOptionsTraits<tflite::TransposeConvOptions> {
2000	static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
2001	};
2002
2003	template<> struct BuiltinOptionsTraits<tflite::SparseToDenseOptions> {
2004	static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
2005	};
2006
2007	template<> struct BuiltinOptionsTraits<tflite::TileOptions> {
2008	static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
2009	};
2010
2011	template<> struct BuiltinOptionsTraits<tflite::ExpandDimsOptions> {
2012	static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
2013	};
2014
2015	template<> struct BuiltinOptionsTraits<tflite::EqualOptions> {
2016	static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
2017	};
2018
2019	template<> struct BuiltinOptionsTraits<tflite::NotEqualOptions> {
2020	static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
2021	};
2022
2023	template<> struct BuiltinOptionsTraits<tflite::ShapeOptions> {
2024	static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
2025	};
2026
2027	template<> struct BuiltinOptionsTraits<tflite::PowOptions> {
2028	static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
2029	};
2030
2031	template<> struct BuiltinOptionsTraits<tflite::ArgMinOptions> {
2032	static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
2033	};
2034
2035	template<> struct BuiltinOptionsTraits<tflite::FakeQuantOptions> {
2036	static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
2037	};
2038
2039	template<> struct BuiltinOptionsTraits<tflite::PackOptions> {
2040	static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
2041	};
2042
2043	template<> struct BuiltinOptionsTraits<tflite::LogicalOrOptions> {
2044	static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
2045	};
2046
2047	template<> struct BuiltinOptionsTraits<tflite::OneHotOptions> {
2048	static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
2049	};
2050
2051	template<> struct BuiltinOptionsTraits<tflite::LogicalAndOptions> {
2052	static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
2053	};
2054
2055	template<> struct BuiltinOptionsTraits<tflite::LogicalNotOptions> {
2056	static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
2057	};
2058
2059	template<> struct BuiltinOptionsTraits<tflite::UnpackOptions> {
2060	static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
2061	};
2062
2063	template<> struct BuiltinOptionsTraits<tflite::FloorDivOptions> {
2064	static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
2065	};
2066
2067	template<> struct BuiltinOptionsTraits<tflite::SquareOptions> {
2068	static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
2069	};
2070
2071	template<> struct BuiltinOptionsTraits<tflite::ZerosLikeOptions> {
2072	static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
2073	};
2074
2075	template<> struct BuiltinOptionsTraits<tflite::FillOptions> {
2076	static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
2077	};
2078
2079	template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceLSTMOptions> {
2080	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
2081	};
2082
2083	template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceRNNOptions> {
2084	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
2085	};
2086
2087	template<> struct BuiltinOptionsTraits<tflite::UnidirectionalSequenceLSTMOptions> {
2088	static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
2089	};
2090
2091	template<> struct BuiltinOptionsTraits<tflite::FloorModOptions> {
2092	static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
2093	};
2094
2095	template<> struct BuiltinOptionsTraits<tflite::RangeOptions> {
2096	static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
2097	};
2098
2099	template<> struct BuiltinOptionsTraits<tflite::ResizeNearestNeighborOptions> {
2100	static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
2101	};
2102
2103	template<> struct BuiltinOptionsTraits<tflite::LeakyReluOptions> {
2104	static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
2105	};
2106
2107	template<> struct BuiltinOptionsTraits<tflite::SquaredDifferenceOptions> {
2108	static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
2109	};
2110
2111	template<> struct BuiltinOptionsTraits<tflite::MirrorPadOptions> {
2112	static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
2113	};
2114
2115	template<> struct BuiltinOptionsTraits<tflite::AbsOptions> {
2116	static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
2117	};
2118
2119	template<> struct BuiltinOptionsTraits<tflite::SplitVOptions> {
2120	static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
2121	};
2122
2123	template<> struct BuiltinOptionsTraits<tflite::UniqueOptions> {
2124	static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
2125	};
2126
2127	template<> struct BuiltinOptionsTraits<tflite::ReverseV2Options> {
2128	static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
2129	};
2130
2131	template<> struct BuiltinOptionsTraits<tflite::AddNOptions> {
2132	static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
2133	};
2134
2135	template<> struct BuiltinOptionsTraits<tflite::GatherNdOptions> {
2136	static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
2137	};
2138
2139	template<> struct BuiltinOptionsTraits<tflite::CosOptions> {
2140	static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
2141	};
2142
2143	template<> struct BuiltinOptionsTraits<tflite::WhereOptions> {
2144	static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
2145	};
2146
2147	template<> struct BuiltinOptionsTraits<tflite::RankOptions> {
2148	static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
2149	};
2150
2151	template<> struct BuiltinOptionsTraits<tflite::ReverseSequenceOptions> {
2152	static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
2153	};
2154
2155	template<> struct BuiltinOptionsTraits<tflite::MatrixDiagOptions> {
2156	static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
2157	};
2158
2159	template<> struct BuiltinOptionsTraits<tflite::QuantizeOptions> {
2160	static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
2161	};
2162
2163	template<> struct BuiltinOptionsTraits<tflite::MatrixSetDiagOptions> {
2164	static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
2165	};
2166
2167	template<> struct BuiltinOptionsTraits<tflite::HardSwishOptions> {
2168	static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
2169	};
2170
2171	template<> struct BuiltinOptionsTraits<tflite::IfOptions> {
2172	static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
2173	};
2174
2175	template<> struct BuiltinOptionsTraits<tflite::WhileOptions> {
2176	static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
2177	};
2178
2179	template<> struct BuiltinOptionsTraits<tflite::DepthToSpaceOptions> {
2180	static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
2181	};
2182
2183	template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV4Options> {
2184	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
2185	};
2186
2187	template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV5Options> {
2188	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
2189	};
2190
2191	template<> struct BuiltinOptionsTraits<tflite::ScatterNdOptions> {
2192	static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
2193	};
2194
2195	template<> struct BuiltinOptionsTraits<tflite::SelectV2Options> {
2196	static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
2197	};
2198
2199	template<> struct BuiltinOptionsTraits<tflite::DensifyOptions> {
2200	static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
2201	};
2202
2203	template<> struct BuiltinOptionsTraits<tflite::SegmentSumOptions> {
2204	static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
2205	};
2206
2207	template<> struct BuiltinOptionsTraits<tflite::BatchMatMulOptions> {
2208	static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
2209	};
2210
2211	template<> struct BuiltinOptionsTraits<tflite::CumsumOptions> {
2212	static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
2213	};
2214
2215	template<> struct BuiltinOptionsTraits<tflite::CallOnceOptions> {
2216	static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
2217	};
2218
2219	template<> struct BuiltinOptionsTraits<tflite::BroadcastToOptions> {
2220	static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
2221	};
2222
2223	template<> struct BuiltinOptionsTraits<tflite::Rfft2dOptions> {
2224	static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
2225	};
2226
2227	template<> struct BuiltinOptionsTraits<tflite::Conv3DOptions> {
2228	static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
2229	};
2230
2231	template<> struct BuiltinOptionsTraits<tflite::HashtableOptions> {
2232	static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
2233	};
2234
2235	template<> struct BuiltinOptionsTraits<tflite::HashtableFindOptions> {
2236	static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
2237	};
2238
2239	template<> struct BuiltinOptionsTraits<tflite::HashtableImportOptions> {
2240	static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
2241	};
2242
2243	template<> struct BuiltinOptionsTraits<tflite::HashtableSizeOptions> {
2244	static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
2245	};
2246
2247	template<> struct BuiltinOptionsTraits<tflite::VarHandleOptions> {
2248	static const BuiltinOptions enum_value = BuiltinOptions_VarHandleOptions;
2249	};
2250
2251	template<> struct BuiltinOptionsTraits<tflite::ReadVariableOptions> {
2252	static const BuiltinOptions enum_value = BuiltinOptions_ReadVariableOptions;
2253	};
2254
2255	template<> struct BuiltinOptionsTraits<tflite::AssignVariableOptions> {
2256	static const BuiltinOptions enum_value = BuiltinOptions_AssignVariableOptions;
2257	};
2258
2259	template<> struct BuiltinOptionsTraits<tflite::RandomOptions> {
2260	static const BuiltinOptions enum_value = BuiltinOptions_RandomOptions;
2261	};
2262
2263	template<> struct BuiltinOptionsTraits<tflite::BucketizeOptions> {
2264	static const BuiltinOptions enum_value = BuiltinOptions_BucketizeOptions;
2265	};
2266
2267	template<> struct BuiltinOptionsTraits<tflite::GeluOptions> {
2268	static const BuiltinOptions enum_value = BuiltinOptions_GeluOptions;
2269	};
2270
2271	template<> struct BuiltinOptionsTraits<tflite::DynamicUpdateSliceOptions> {
2272	static const BuiltinOptions enum_value = BuiltinOptions_DynamicUpdateSliceOptions;
2273	};
2274
2275	template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentProdOptions> {
2276	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentProdOptions;
2277	};
2278
2279	template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMaxOptions> {
2280	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentMaxOptions;
2281	};
2282
2283	template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMinOptions> {
2284	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentMinOptions;
2285	};
2286
2287	template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentSumOptions> {
2288	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentSumOptions;
2289	};
2290
2291	template<> struct BuiltinOptionsTraits<tflite::ATan2Options> {
2292	static const BuiltinOptions enum_value = BuiltinOptions_ATan2Options;
2293	};
2294
2295	template<> struct BuiltinOptionsTraits<tflite::SignOptions> {
2296	static const BuiltinOptions enum_value = BuiltinOptions_SignOptions;
2297	};
2298
2299	template<typename T> struct BuiltinOptionsUnionTraits {
2300	static const BuiltinOptions enum_value = BuiltinOptions_NONE;
2301	};
2302
2303	template<> struct BuiltinOptionsUnionTraits<tflite::Conv2DOptionsT> {
2304	static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions;
2305	};
2306
2307	template<> struct BuiltinOptionsUnionTraits<tflite::DepthwiseConv2DOptionsT> {
2308	static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions;
2309	};
2310
2311	template<> struct BuiltinOptionsUnionTraits<tflite::ConcatEmbeddingsOptionsT> {
2312	static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions;
2313	};
2314
2315	template<> struct BuiltinOptionsUnionTraits<tflite::LSHProjectionOptionsT> {
2316	static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions;
2317	};
2318
2319	template<> struct BuiltinOptionsUnionTraits<tflite::Pool2DOptionsT> {
2320	static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions;
2321	};
2322
2323	template<> struct BuiltinOptionsUnionTraits<tflite::SVDFOptionsT> {
2324	static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions;
2325	};
2326
2327	template<> struct BuiltinOptionsUnionTraits<tflite::RNNOptionsT> {
2328	static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions;
2329	};
2330
2331	template<> struct BuiltinOptionsUnionTraits<tflite::FullyConnectedOptionsT> {
2332	static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions;
2333	};
2334
2335	template<> struct BuiltinOptionsUnionTraits<tflite::SoftmaxOptionsT> {
2336	static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions;
2337	};
2338
2339	template<> struct BuiltinOptionsUnionTraits<tflite::ConcatenationOptionsT> {
2340	static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions;
2341	};
2342
2343	template<> struct BuiltinOptionsUnionTraits<tflite::AddOptionsT> {
2344	static const BuiltinOptions enum_value = BuiltinOptions_AddOptions;
2345	};
2346
2347	template<> struct BuiltinOptionsUnionTraits<tflite::L2NormOptionsT> {
2348	static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions;
2349	};
2350
2351	template<> struct BuiltinOptionsUnionTraits<tflite::LocalResponseNormalizationOptionsT> {
2352	static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions;
2353	};
2354
2355	template<> struct BuiltinOptionsUnionTraits<tflite::LSTMOptionsT> {
2356	static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions;
2357	};
2358
2359	template<> struct BuiltinOptionsUnionTraits<tflite::ResizeBilinearOptionsT> {
2360	static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions;
2361	};
2362
2363	template<> struct BuiltinOptionsUnionTraits<tflite::CallOptionsT> {
2364	static const BuiltinOptions enum_value = BuiltinOptions_CallOptions;
2365	};
2366
2367	template<> struct BuiltinOptionsUnionTraits<tflite::ReshapeOptionsT> {
2368	static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions;
2369	};
2370
2371	template<> struct BuiltinOptionsUnionTraits<tflite::SkipGramOptionsT> {
2372	static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions;
2373	};
2374
2375	template<> struct BuiltinOptionsUnionTraits<tflite::SpaceToDepthOptionsT> {
2376	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions;
2377	};
2378
2379	template<> struct BuiltinOptionsUnionTraits<tflite::EmbeddingLookupSparseOptionsT> {
2380	static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions;
2381	};
2382
2383	template<> struct BuiltinOptionsUnionTraits<tflite::MulOptionsT> {
2384	static const BuiltinOptions enum_value = BuiltinOptions_MulOptions;
2385	};
2386
2387	template<> struct BuiltinOptionsUnionTraits<tflite::PadOptionsT> {
2388	static const BuiltinOptions enum_value = BuiltinOptions_PadOptions;
2389	};
2390
2391	template<> struct BuiltinOptionsUnionTraits<tflite::GatherOptionsT> {
2392	static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions;
2393	};
2394
2395	template<> struct BuiltinOptionsUnionTraits<tflite::BatchToSpaceNDOptionsT> {
2396	static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions;
2397	};
2398
2399	template<> struct BuiltinOptionsUnionTraits<tflite::SpaceToBatchNDOptionsT> {
2400	static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions;
2401	};
2402
2403	template<> struct BuiltinOptionsUnionTraits<tflite::TransposeOptionsT> {
2404	static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions;
2405	};
2406
2407	template<> struct BuiltinOptionsUnionTraits<tflite::ReducerOptionsT> {
2408	static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions;
2409	};
2410
2411	template<> struct BuiltinOptionsUnionTraits<tflite::SubOptionsT> {
2412	static const BuiltinOptions enum_value = BuiltinOptions_SubOptions;
2413	};
2414
2415	template<> struct BuiltinOptionsUnionTraits<tflite::DivOptionsT> {
2416	static const BuiltinOptions enum_value = BuiltinOptions_DivOptions;
2417	};
2418
2419	template<> struct BuiltinOptionsUnionTraits<tflite::SqueezeOptionsT> {
2420	static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions;
2421	};
2422
2423	template<> struct BuiltinOptionsUnionTraits<tflite::SequenceRNNOptionsT> {
2424	static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions;
2425	};
2426
2427	template<> struct BuiltinOptionsUnionTraits<tflite::StridedSliceOptionsT> {
2428	static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions;
2429	};
2430
2431	template<> struct BuiltinOptionsUnionTraits<tflite::ExpOptionsT> {
2432	static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions;
2433	};
2434
2435	template<> struct BuiltinOptionsUnionTraits<tflite::TopKV2OptionsT> {
2436	static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options;
2437	};
2438
2439	template<> struct BuiltinOptionsUnionTraits<tflite::SplitOptionsT> {
2440	static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions;
2441	};
2442
2443	template<> struct BuiltinOptionsUnionTraits<tflite::LogSoftmaxOptionsT> {
2444	static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions;
2445	};
2446
2447	template<> struct BuiltinOptionsUnionTraits<tflite::CastOptionsT> {
2448	static const BuiltinOptions enum_value = BuiltinOptions_CastOptions;
2449	};
2450
2451	template<> struct BuiltinOptionsUnionTraits<tflite::DequantizeOptionsT> {
2452	static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions;
2453	};
2454
2455	template<> struct BuiltinOptionsUnionTraits<tflite::MaximumMinimumOptionsT> {
2456	static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions;
2457	};
2458
2459	template<> struct BuiltinOptionsUnionTraits<tflite::ArgMaxOptionsT> {
2460	static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions;
2461	};
2462
2463	template<> struct BuiltinOptionsUnionTraits<tflite::LessOptionsT> {
2464	static const BuiltinOptions enum_value = BuiltinOptions_LessOptions;
2465	};
2466
2467	template<> struct BuiltinOptionsUnionTraits<tflite::NegOptionsT> {
2468	static const BuiltinOptions enum_value = BuiltinOptions_NegOptions;
2469	};
2470
2471	template<> struct BuiltinOptionsUnionTraits<tflite::PadV2OptionsT> {
2472	static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options;
2473	};
2474
2475	template<> struct BuiltinOptionsUnionTraits<tflite::GreaterOptionsT> {
2476	static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions;
2477	};
2478
2479	template<> struct BuiltinOptionsUnionTraits<tflite::GreaterEqualOptionsT> {
2480	static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions;
2481	};
2482
2483	template<> struct BuiltinOptionsUnionTraits<tflite::LessEqualOptionsT> {
2484	static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions;
2485	};
2486
2487	template<> struct BuiltinOptionsUnionTraits<tflite::SelectOptionsT> {
2488	static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions;
2489	};
2490
2491	template<> struct BuiltinOptionsUnionTraits<tflite::SliceOptionsT> {
2492	static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions;
2493	};
2494
2495	template<> struct BuiltinOptionsUnionTraits<tflite::TransposeConvOptionsT> {
2496	static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions;
2497	};
2498
2499	template<> struct BuiltinOptionsUnionTraits<tflite::SparseToDenseOptionsT> {
2500	static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions;
2501	};
2502
2503	template<> struct BuiltinOptionsUnionTraits<tflite::TileOptionsT> {
2504	static const BuiltinOptions enum_value = BuiltinOptions_TileOptions;
2505	};
2506
2507	template<> struct BuiltinOptionsUnionTraits<tflite::ExpandDimsOptionsT> {
2508	static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions;
2509	};
2510
2511	template<> struct BuiltinOptionsUnionTraits<tflite::EqualOptionsT> {
2512	static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions;
2513	};
2514
2515	template<> struct BuiltinOptionsUnionTraits<tflite::NotEqualOptionsT> {
2516	static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions;
2517	};
2518
2519	template<> struct BuiltinOptionsUnionTraits<tflite::ShapeOptionsT> {
2520	static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions;
2521	};
2522
2523	template<> struct BuiltinOptionsUnionTraits<tflite::PowOptionsT> {
2524	static const BuiltinOptions enum_value = BuiltinOptions_PowOptions;
2525	};
2526
2527	template<> struct BuiltinOptionsUnionTraits<tflite::ArgMinOptionsT> {
2528	static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions;
2529	};
2530
2531	template<> struct BuiltinOptionsUnionTraits<tflite::FakeQuantOptionsT> {
2532	static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions;
2533	};
2534
2535	template<> struct BuiltinOptionsUnionTraits<tflite::PackOptionsT> {
2536	static const BuiltinOptions enum_value = BuiltinOptions_PackOptions;
2537	};
2538
2539	template<> struct BuiltinOptionsUnionTraits<tflite::LogicalOrOptionsT> {
2540	static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions;
2541	};
2542
2543	template<> struct BuiltinOptionsUnionTraits<tflite::OneHotOptionsT> {
2544	static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions;
2545	};
2546
2547	template<> struct BuiltinOptionsUnionTraits<tflite::LogicalAndOptionsT> {
2548	static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions;
2549	};
2550
2551	template<> struct BuiltinOptionsUnionTraits<tflite::LogicalNotOptionsT> {
2552	static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions;
2553	};
2554
2555	template<> struct BuiltinOptionsUnionTraits<tflite::UnpackOptionsT> {
2556	static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions;
2557	};
2558
2559	template<> struct BuiltinOptionsUnionTraits<tflite::FloorDivOptionsT> {
2560	static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions;
2561	};
2562
2563	template<> struct BuiltinOptionsUnionTraits<tflite::SquareOptionsT> {
2564	static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions;
2565	};
2566
2567	template<> struct BuiltinOptionsUnionTraits<tflite::ZerosLikeOptionsT> {
2568	static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions;
2569	};
2570
2571	template<> struct BuiltinOptionsUnionTraits<tflite::FillOptionsT> {
2572	static const BuiltinOptions enum_value = BuiltinOptions_FillOptions;
2573	};
2574
2575	template<> struct BuiltinOptionsUnionTraits<tflite::BidirectionalSequenceLSTMOptionsT> {
2576	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions;
2577	};
2578
2579	template<> struct BuiltinOptionsUnionTraits<tflite::BidirectionalSequenceRNNOptionsT> {
2580	static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions;
2581	};
2582
2583	template<> struct BuiltinOptionsUnionTraits<tflite::UnidirectionalSequenceLSTMOptionsT> {
2584	static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions;
2585	};
2586
2587	template<> struct BuiltinOptionsUnionTraits<tflite::FloorModOptionsT> {
2588	static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions;
2589	};
2590
2591	template<> struct BuiltinOptionsUnionTraits<tflite::RangeOptionsT> {
2592	static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions;
2593	};
2594
2595	template<> struct BuiltinOptionsUnionTraits<tflite::ResizeNearestNeighborOptionsT> {
2596	static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions;
2597	};
2598
2599	template<> struct BuiltinOptionsUnionTraits<tflite::LeakyReluOptionsT> {
2600	static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions;
2601	};
2602
2603	template<> struct BuiltinOptionsUnionTraits<tflite::SquaredDifferenceOptionsT> {
2604	static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions;
2605	};
2606
2607	template<> struct BuiltinOptionsUnionTraits<tflite::MirrorPadOptionsT> {
2608	static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions;
2609	};
2610
2611	template<> struct BuiltinOptionsUnionTraits<tflite::AbsOptionsT> {
2612	static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions;
2613	};
2614
2615	template<> struct BuiltinOptionsUnionTraits<tflite::SplitVOptionsT> {
2616	static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
2617	};
2618
2619	template<> struct BuiltinOptionsUnionTraits<tflite::UniqueOptionsT> {
2620	static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions;
2621	};
2622
2623	template<> struct BuiltinOptionsUnionTraits<tflite::ReverseV2OptionsT> {
2624	static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options;
2625	};
2626
2627	template<> struct BuiltinOptionsUnionTraits<tflite::AddNOptionsT> {
2628	static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions;
2629	};
2630
2631	template<> struct BuiltinOptionsUnionTraits<tflite::GatherNdOptionsT> {
2632	static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions;
2633	};
2634
2635	template<> struct BuiltinOptionsUnionTraits<tflite::CosOptionsT> {
2636	static const BuiltinOptions enum_value = BuiltinOptions_CosOptions;
2637	};
2638
2639	template<> struct BuiltinOptionsUnionTraits<tflite::WhereOptionsT> {
2640	static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions;
2641	};
2642
2643	template<> struct BuiltinOptionsUnionTraits<tflite::RankOptionsT> {
2644	static const BuiltinOptions enum_value = BuiltinOptions_RankOptions;
2645	};
2646
2647	template<> struct BuiltinOptionsUnionTraits<tflite::ReverseSequenceOptionsT> {
2648	static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions;
2649	};
2650
2651	template<> struct BuiltinOptionsUnionTraits<tflite::MatrixDiagOptionsT> {
2652	static const BuiltinOptions enum_value = BuiltinOptions_MatrixDiagOptions;
2653	};
2654
2655	template<> struct BuiltinOptionsUnionTraits<tflite::QuantizeOptionsT> {
2656	static const BuiltinOptions enum_value = BuiltinOptions_QuantizeOptions;
2657	};
2658
2659	template<> struct BuiltinOptionsUnionTraits<tflite::MatrixSetDiagOptionsT> {
2660	static const BuiltinOptions enum_value = BuiltinOptions_MatrixSetDiagOptions;
2661	};
2662
2663	template<> struct BuiltinOptionsUnionTraits<tflite::HardSwishOptionsT> {
2664	static const BuiltinOptions enum_value = BuiltinOptions_HardSwishOptions;
2665	};
2666
2667	template<> struct BuiltinOptionsUnionTraits<tflite::IfOptionsT> {
2668	static const BuiltinOptions enum_value = BuiltinOptions_IfOptions;
2669	};
2670
2671	template<> struct BuiltinOptionsUnionTraits<tflite::WhileOptionsT> {
2672	static const BuiltinOptions enum_value = BuiltinOptions_WhileOptions;
2673	};
2674
2675	template<> struct BuiltinOptionsUnionTraits<tflite::DepthToSpaceOptionsT> {
2676	static const BuiltinOptions enum_value = BuiltinOptions_DepthToSpaceOptions;
2677	};
2678
2679	template<> struct BuiltinOptionsUnionTraits<tflite::NonMaxSuppressionV4OptionsT> {
2680	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV4Options;
2681	};
2682
2683	template<> struct BuiltinOptionsUnionTraits<tflite::NonMaxSuppressionV5OptionsT> {
2684	static const BuiltinOptions enum_value = BuiltinOptions_NonMaxSuppressionV5Options;
2685	};
2686
2687	template<> struct BuiltinOptionsUnionTraits<tflite::ScatterNdOptionsT> {
2688	static const BuiltinOptions enum_value = BuiltinOptions_ScatterNdOptions;
2689	};
2690
2691	template<> struct BuiltinOptionsUnionTraits<tflite::SelectV2OptionsT> {
2692	static const BuiltinOptions enum_value = BuiltinOptions_SelectV2Options;
2693	};
2694
2695	template<> struct BuiltinOptionsUnionTraits<tflite::DensifyOptionsT> {
2696	static const BuiltinOptions enum_value = BuiltinOptions_DensifyOptions;
2697	};
2698
2699	template<> struct BuiltinOptionsUnionTraits<tflite::SegmentSumOptionsT> {
2700	static const BuiltinOptions enum_value = BuiltinOptions_SegmentSumOptions;
2701	};
2702
2703	template<> struct BuiltinOptionsUnionTraits<tflite::BatchMatMulOptionsT> {
2704	static const BuiltinOptions enum_value = BuiltinOptions_BatchMatMulOptions;
2705	};
2706
2707	template<> struct BuiltinOptionsUnionTraits<tflite::CumsumOptionsT> {
2708	static const BuiltinOptions enum_value = BuiltinOptions_CumsumOptions;
2709	};
2710
2711	template<> struct BuiltinOptionsUnionTraits<tflite::CallOnceOptionsT> {
2712	static const BuiltinOptions enum_value = BuiltinOptions_CallOnceOptions;
2713	};
2714
2715	template<> struct BuiltinOptionsUnionTraits<tflite::BroadcastToOptionsT> {
2716	static const BuiltinOptions enum_value = BuiltinOptions_BroadcastToOptions;
2717	};
2718
2719	template<> struct BuiltinOptionsUnionTraits<tflite::Rfft2dOptionsT> {
2720	static const BuiltinOptions enum_value = BuiltinOptions_Rfft2dOptions;
2721	};
2722
2723	template<> struct BuiltinOptionsUnionTraits<tflite::Conv3DOptionsT> {
2724	static const BuiltinOptions enum_value = BuiltinOptions_Conv3DOptions;
2725	};
2726
2727	template<> struct BuiltinOptionsUnionTraits<tflite::HashtableOptionsT> {
2728	static const BuiltinOptions enum_value = BuiltinOptions_HashtableOptions;
2729	};
2730
2731	template<> struct BuiltinOptionsUnionTraits<tflite::HashtableFindOptionsT> {
2732	static const BuiltinOptions enum_value = BuiltinOptions_HashtableFindOptions;
2733	};
2734
2735	template<> struct BuiltinOptionsUnionTraits<tflite::HashtableImportOptionsT> {
2736	static const BuiltinOptions enum_value = BuiltinOptions_HashtableImportOptions;
2737	};
2738
2739	template<> struct BuiltinOptionsUnionTraits<tflite::HashtableSizeOptionsT> {
2740	static const BuiltinOptions enum_value = BuiltinOptions_HashtableSizeOptions;
2741	};
2742
2743	template<> struct BuiltinOptionsUnionTraits<tflite::VarHandleOptionsT> {
2744	static const BuiltinOptions enum_value = BuiltinOptions_VarHandleOptions;
2745	};
2746
2747	template<> struct BuiltinOptionsUnionTraits<tflite::ReadVariableOptionsT> {
2748	static const BuiltinOptions enum_value = BuiltinOptions_ReadVariableOptions;
2749	};
2750
2751	template<> struct BuiltinOptionsUnionTraits<tflite::AssignVariableOptionsT> {
2752	static const BuiltinOptions enum_value = BuiltinOptions_AssignVariableOptions;
2753	};
2754
2755	template<> struct BuiltinOptionsUnionTraits<tflite::RandomOptionsT> {
2756	static const BuiltinOptions enum_value = BuiltinOptions_RandomOptions;
2757	};
2758
2759	template<> struct BuiltinOptionsUnionTraits<tflite::BucketizeOptionsT> {
2760	static const BuiltinOptions enum_value = BuiltinOptions_BucketizeOptions;
2761	};
2762
2763	template<> struct BuiltinOptionsUnionTraits<tflite::GeluOptionsT> {
2764	static const BuiltinOptions enum_value = BuiltinOptions_GeluOptions;
2765	};
2766
2767	template<> struct BuiltinOptionsUnionTraits<tflite::DynamicUpdateSliceOptionsT> {
2768	static const BuiltinOptions enum_value = BuiltinOptions_DynamicUpdateSliceOptions;
2769	};
2770
2771	template<> struct BuiltinOptionsUnionTraits<tflite::UnsortedSegmentProdOptionsT> {
2772	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentProdOptions;
2773	};
2774
2775	template<> struct BuiltinOptionsUnionTraits<tflite::UnsortedSegmentMaxOptionsT> {
2776	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentMaxOptions;
2777	};
2778
2779	template<> struct BuiltinOptionsUnionTraits<tflite::UnsortedSegmentMinOptionsT> {
2780	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentMinOptions;
2781	};
2782
2783	template<> struct BuiltinOptionsUnionTraits<tflite::UnsortedSegmentSumOptionsT> {
2784	static const BuiltinOptions enum_value = BuiltinOptions_UnsortedSegmentSumOptions;
2785	};
2786
2787	template<> struct BuiltinOptionsUnionTraits<tflite::ATan2OptionsT> {
2788	static const BuiltinOptions enum_value = BuiltinOptions_ATan2Options;
2789	};
2790
2791	template<> struct BuiltinOptionsUnionTraits<tflite::SignOptionsT> {
2792	static const BuiltinOptions enum_value = BuiltinOptions_SignOptions;
2793	};
2794
2795	struct BuiltinOptionsUnion {
2796	BuiltinOptions type;
2797	void *value;
2798
2799	BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {}
2800	BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
2801	type(BuiltinOptions_NONE), value(nullptr)
2802	{ std::swap(type, u.type); std::swap(value, u.value); }
2803	BuiltinOptionsUnion(const BuiltinOptionsUnion &);
2804	BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u)
2805	{ BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
2806	BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
2807	{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
2808	~BuiltinOptionsUnion() { Reset(); }
2809
2810	void Reset();
2811
2812	template <typename T>
2813	void Set(T&& val) {
2814	typedef typename std::remove_reference<T>::type RT;
2815	Reset();
2816	type = BuiltinOptionsUnionTraits<RT>::enum_value;
2817	if (type != BuiltinOptions_NONE) {
2818	value = new RT(std::forward<T>(val));
2819	}
2820	}
2821
2822	static void UnPack(const* void obj, BuiltinOptions type, const* flatbuffers::resolver_function_t *resolver);
2823	flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher = nullptr) const*;
2824
2825	tflite::Conv2DOptionsT *AsConv2DOptions() {
2826	return type == BuiltinOptions_Conv2DOptions ?
2827	reinterpret_cast<tflite::Conv2DOptionsT >(value) : nullptr*;
2828	}
2829	const tflite::Conv2DOptionsT AsConv2DOptions() const* {
2830	return type == BuiltinOptions_Conv2DOptions ?
2831	reinterpret_cast<const tflite::Conv2DOptionsT >(value) : nullptr*;
2832	}
2833	tflite::DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() {
2834	return type == BuiltinOptions_DepthwiseConv2DOptions ?
2835	reinterpret_cast<tflite::DepthwiseConv2DOptionsT >(value) : nullptr*;
2836	}
2837	const tflite::DepthwiseConv2DOptionsT AsDepthwiseConv2DOptions() const* {
2838	return type == BuiltinOptions_DepthwiseConv2DOptions ?
2839	reinterpret_cast<const tflite::DepthwiseConv2DOptionsT >(value) : nullptr*;
2840	}
2841	tflite::ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() {
2842	return type == BuiltinOptions_ConcatEmbeddingsOptions ?
2843	reinterpret_cast<tflite::ConcatEmbeddingsOptionsT >(value) : nullptr*;
2844	}
2845	const tflite::ConcatEmbeddingsOptionsT AsConcatEmbeddingsOptions() const* {
2846	return type == BuiltinOptions_ConcatEmbeddingsOptions ?
2847	reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT >(value) : nullptr*;
2848	}
2849	tflite::LSHProjectionOptionsT *AsLSHProjectionOptions() {
2850	return type == BuiltinOptions_LSHProjectionOptions ?
2851	reinterpret_cast<tflite::LSHProjectionOptionsT >(value) : nullptr*;
2852	}
2853	const tflite::LSHProjectionOptionsT AsLSHProjectionOptions() const* {
2854	return type == BuiltinOptions_LSHProjectionOptions ?
2855	reinterpret_cast<const tflite::LSHProjectionOptionsT >(value) : nullptr*;
2856	}
2857	tflite::Pool2DOptionsT *AsPool2DOptions() {
2858	return type == BuiltinOptions_Pool2DOptions ?
2859	reinterpret_cast<tflite::Pool2DOptionsT >(value) : nullptr*;
2860	}
2861	const tflite::Pool2DOptionsT AsPool2DOptions() const* {
2862	return type == BuiltinOptions_Pool2DOptions ?
2863	reinterpret_cast<const tflite::Pool2DOptionsT >(value) : nullptr*;
2864	}
2865	tflite::SVDFOptionsT *AsSVDFOptions() {
2866	return type == BuiltinOptions_SVDFOptions ?
2867	reinterpret_cast<tflite::SVDFOptionsT >(value) : nullptr*;
2868	}
2869	const tflite::SVDFOptionsT AsSVDFOptions() const* {
2870	return type == BuiltinOptions_SVDFOptions ?
2871	reinterpret_cast<const tflite::SVDFOptionsT >(value) : nullptr*;
2872	}
2873	tflite::RNNOptionsT *AsRNNOptions() {
2874	return type == BuiltinOptions_RNNOptions ?
2875	reinterpret_cast<tflite::RNNOptionsT >(value) : nullptr*;
2876	}
2877	const tflite::RNNOptionsT AsRNNOptions() const* {
2878	return type == BuiltinOptions_RNNOptions ?
2879	reinterpret_cast<const tflite::RNNOptionsT >(value) : nullptr*;
2880	}
2881	tflite::FullyConnectedOptionsT *AsFullyConnectedOptions() {
2882	return type == BuiltinOptions_FullyConnectedOptions ?
2883	reinterpret_cast<tflite::FullyConnectedOptionsT >(value) : nullptr*;
2884	}
2885	const tflite::FullyConnectedOptionsT AsFullyConnectedOptions() const* {
2886	return type == BuiltinOptions_FullyConnectedOptions ?
2887	reinterpret_cast<const tflite::FullyConnectedOptionsT >(value) : nullptr*;
2888	}
2889	tflite::SoftmaxOptionsT *AsSoftmaxOptions() {
2890	return type == BuiltinOptions_SoftmaxOptions ?
2891	reinterpret_cast<tflite::SoftmaxOptionsT >(value) : nullptr*;
2892	}
2893	const tflite::SoftmaxOptionsT AsSoftmaxOptions() const* {
2894	return type == BuiltinOptions_SoftmaxOptions ?
2895	reinterpret_cast<const tflite::SoftmaxOptionsT >(value) : nullptr*;
2896	}
2897	tflite::ConcatenationOptionsT *AsConcatenationOptions() {
2898	return type == BuiltinOptions_ConcatenationOptions ?
2899	reinterpret_cast<tflite::ConcatenationOptionsT >(value) : nullptr*;
2900	}
2901	const tflite::ConcatenationOptionsT AsConcatenationOptions() const* {
2902	return type == BuiltinOptions_ConcatenationOptions ?
2903	reinterpret_cast<const tflite::ConcatenationOptionsT >(value) : nullptr*;
2904	}
2905	tflite::AddOptionsT *AsAddOptions() {
2906	return type == BuiltinOptions_AddOptions ?
2907	reinterpret_cast<tflite::AddOptionsT >(value) : nullptr*;
2908	}
2909	const tflite::AddOptionsT AsAddOptions() const* {
2910	return type == BuiltinOptions_AddOptions ?
2911	reinterpret_cast<const tflite::AddOptionsT >(value) : nullptr*;
2912	}
2913	tflite::L2NormOptionsT *AsL2NormOptions() {
2914	return type == BuiltinOptions_L2NormOptions ?
2915	reinterpret_cast<tflite::L2NormOptionsT >(value) : nullptr*;
2916	}
2917	const tflite::L2NormOptionsT AsL2NormOptions() const* {
2918	return type == BuiltinOptions_L2NormOptions ?
2919	reinterpret_cast<const tflite::L2NormOptionsT >(value) : nullptr*;
2920	}
2921	tflite::LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() {
2922	return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2923	reinterpret_cast<tflite::LocalResponseNormalizationOptionsT >(value) : nullptr*;
2924	}
2925	const tflite::LocalResponseNormalizationOptionsT AsLocalResponseNormalizationOptions() const* {
2926	return type == BuiltinOptions_LocalResponseNormalizationOptions ?
2927	reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT >(value) : nullptr*;
2928	}
2929	tflite::LSTMOptionsT *AsLSTMOptions() {
2930	return type == BuiltinOptions_LSTMOptions ?
2931	reinterpret_cast<tflite::LSTMOptionsT >(value) : nullptr*;
2932	}
2933	const tflite::LSTMOptionsT AsLSTMOptions() const* {
2934	return type == BuiltinOptions_LSTMOptions ?
2935	reinterpret_cast<const tflite::LSTMOptionsT >(value) : nullptr*;
2936	}
2937	tflite::ResizeBilinearOptionsT *AsResizeBilinearOptions() {
2938	return type == BuiltinOptions_ResizeBilinearOptions ?
2939	reinterpret_cast<tflite::ResizeBilinearOptionsT >(value) : nullptr*;
2940	}
2941	const tflite::ResizeBilinearOptionsT AsResizeBilinearOptions() const* {
2942	return type == BuiltinOptions_ResizeBilinearOptions ?
2943	reinterpret_cast<const tflite::ResizeBilinearOptionsT >(value) : nullptr*;
2944	}
2945	tflite::CallOptionsT *AsCallOptions() {
2946	return type == BuiltinOptions_CallOptions ?
2947	reinterpret_cast<tflite::CallOptionsT >(value) : nullptr*;
2948	}
2949	const tflite::CallOptionsT AsCallOptions() const* {
2950	return type == BuiltinOptions_CallOptions ?
2951	reinterpret_cast<const tflite::CallOptionsT >(value) : nullptr*;
2952	}
2953	tflite::ReshapeOptionsT *AsReshapeOptions() {
2954	return type == BuiltinOptions_ReshapeOptions ?
2955	reinterpret_cast<tflite::ReshapeOptionsT >(value) : nullptr*;
2956	}
2957	const tflite::ReshapeOptionsT AsReshapeOptions() const* {
2958	return type == BuiltinOptions_ReshapeOptions ?
2959	reinterpret_cast<const tflite::ReshapeOptionsT >(value) : nullptr*;
2960	}
2961	tflite::SkipGramOptionsT *AsSkipGramOptions() {
2962	return type == BuiltinOptions_SkipGramOptions ?
2963	reinterpret_cast<tflite::SkipGramOptionsT >(value) : nullptr*;
2964	}
2965	const tflite::SkipGramOptionsT AsSkipGramOptions() const* {
2966	return type == BuiltinOptions_SkipGramOptions ?
2967	reinterpret_cast<const tflite::SkipGramOptionsT >(value) : nullptr*;
2968	}
2969	tflite::SpaceToDepthOptionsT *AsSpaceToDepthOptions() {
2970	return type == BuiltinOptions_SpaceToDepthOptions ?
2971	reinterpret_cast<tflite::SpaceToDepthOptionsT >(value) : nullptr*;
2972	}
2973	const tflite::SpaceToDepthOptionsT AsSpaceToDepthOptions() const* {
2974	return type == BuiltinOptions_SpaceToDepthOptions ?
2975	reinterpret_cast<const tflite::SpaceToDepthOptionsT >(value) : nullptr*;
2976	}
2977	tflite::EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() {
2978	return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2979	reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT >(value) : nullptr*;
2980	}
2981	const tflite::EmbeddingLookupSparseOptionsT AsEmbeddingLookupSparseOptions() const* {
2982	return type == BuiltinOptions_EmbeddingLookupSparseOptions ?
2983	reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT >(value) : nullptr*;
2984	}
2985	tflite::MulOptionsT *AsMulOptions() {
2986	return type == BuiltinOptions_MulOptions ?
2987	reinterpret_cast<tflite::MulOptionsT >(value) : nullptr*;
2988	}
2989	const tflite::MulOptionsT AsMulOptions() const* {
2990	return type == BuiltinOptions_MulOptions ?
2991	reinterpret_cast<const tflite::MulOptionsT >(value) : nullptr*;
2992	}
2993	tflite::PadOptionsT *AsPadOptions() {
2994	return type == BuiltinOptions_PadOptions ?
2995	reinterpret_cast<tflite::PadOptionsT >(value) : nullptr*;
2996	}
2997	const tflite::PadOptionsT AsPadOptions() const* {
2998	return type == BuiltinOptions_PadOptions ?
2999	reinterpret_cast<const tflite::PadOptionsT >(value) : nullptr*;
3000	}
3001	tflite::GatherOptionsT *AsGatherOptions() {
3002	return type == BuiltinOptions_GatherOptions ?
3003	reinterpret_cast<tflite::GatherOptionsT >(value) : nullptr*;
3004	}
3005	const tflite::GatherOptionsT AsGatherOptions() const* {
3006	return type == BuiltinOptions_GatherOptions ?
3007	reinterpret_cast<const tflite::GatherOptionsT >(value) : nullptr*;
3008	}
3009	tflite::BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() {
3010	return type == BuiltinOptions_BatchToSpaceNDOptions ?
3011	reinterpret_cast<tflite::BatchToSpaceNDOptionsT >(value) : nullptr*;
3012	}
3013	const tflite::BatchToSpaceNDOptionsT AsBatchToSpaceNDOptions() const* {
3014	return type == BuiltinOptions_BatchToSpaceNDOptions ?
3015	reinterpret_cast<const tflite::BatchToSpaceNDOptionsT >(value) : nullptr*;
3016	}
3017	tflite::SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() {
3018	return type == BuiltinOptions_SpaceToBatchNDOptions ?
3019	reinterpret_cast<tflite::SpaceToBatchNDOptionsT >(value) : nullptr*;
3020	}
3021	const tflite::SpaceToBatchNDOptionsT AsSpaceToBatchNDOptions() const* {
3022	return type == BuiltinOptions_SpaceToBatchNDOptions ?
3023	reinterpret_cast<const tflite::SpaceToBatchNDOptionsT >(value) : nullptr*;
3024	}
3025	tflite::TransposeOptionsT *AsTransposeOptions() {
3026	return type == BuiltinOptions_TransposeOptions ?
3027	reinterpret_cast<tflite::TransposeOptionsT >(value) : nullptr*;
3028	}
3029	const tflite::TransposeOptionsT AsTransposeOptions() const* {
3030	return type == BuiltinOptions_TransposeOptions ?
3031	reinterpret_cast<const tflite::TransposeOptionsT >(value) : nullptr*;
3032	}
3033	tflite::ReducerOptionsT *AsReducerOptions() {
3034	return type == BuiltinOptions_ReducerOptions ?
3035	reinterpret_cast<tflite::ReducerOptionsT >(value) : nullptr*;
3036	}
3037	const tflite::ReducerOptionsT AsReducerOptions() const* {
3038	return type == BuiltinOptions_ReducerOptions ?
3039	reinterpret_cast<const tflite::ReducerOptionsT >(value) : nullptr*;
3040	}
3041	tflite::SubOptionsT *AsSubOptions() {
3042	return type == BuiltinOptions_SubOptions ?
3043	reinterpret_cast<tflite::SubOptionsT >(value) : nullptr*;
3044	}
3045	const tflite::SubOptionsT AsSubOptions() const* {
3046	return type == BuiltinOptions_SubOptions ?
3047	reinterpret_cast<const tflite::SubOptionsT >(value) : nullptr*;
3048	}
3049	tflite::DivOptionsT *AsDivOptions() {
3050	return type == BuiltinOptions_DivOptions ?
3051	reinterpret_cast<tflite::DivOptionsT >(value) : nullptr*;
3052	}
3053	const tflite::DivOptionsT AsDivOptions() const* {
3054	return type == BuiltinOptions_DivOptions ?
3055	reinterpret_cast<const tflite::DivOptionsT >(value) : nullptr*;
3056	}
3057	tflite::SqueezeOptionsT *AsSqueezeOptions() {
3058	return type == BuiltinOptions_SqueezeOptions ?
3059	reinterpret_cast<tflite::SqueezeOptionsT >(value) : nullptr*;
3060	}
3061	const tflite::SqueezeOptionsT AsSqueezeOptions() const* {
3062	return type == BuiltinOptions_SqueezeOptions ?
3063	reinterpret_cast<const tflite::SqueezeOptionsT >(value) : nullptr*;
3064	}
3065	tflite::SequenceRNNOptionsT *AsSequenceRNNOptions() {
3066	return type == BuiltinOptions_SequenceRNNOptions ?
3067	reinterpret_cast<tflite::SequenceRNNOptionsT >(value) : nullptr*;
3068	}
3069	const tflite::SequenceRNNOptionsT AsSequenceRNNOptions() const* {
3070	return type == BuiltinOptions_SequenceRNNOptions ?
3071	reinterpret_cast<const tflite::SequenceRNNOptionsT >(value) : nullptr*;
3072	}
3073	tflite::StridedSliceOptionsT *AsStridedSliceOptions() {
3074	return type == BuiltinOptions_StridedSliceOptions ?
3075	reinterpret_cast<tflite::StridedSliceOptionsT >(value) : nullptr*;
3076	}
3077	const tflite::StridedSliceOptionsT AsStridedSliceOptions() const* {
3078	return type == BuiltinOptions_StridedSliceOptions ?
3079	reinterpret_cast<const tflite::StridedSliceOptionsT >(value) : nullptr*;
3080	}
3081	tflite::ExpOptionsT *AsExpOptions() {
3082	return type == BuiltinOptions_ExpOptions ?
3083	reinterpret_cast<tflite::ExpOptionsT >(value) : nullptr*;
3084	}
3085	const tflite::ExpOptionsT AsExpOptions() const* {
3086	return type == BuiltinOptions_ExpOptions ?
3087	reinterpret_cast<const tflite::ExpOptionsT >(value) : nullptr*;
3088	}
3089	tflite::TopKV2OptionsT *AsTopKV2Options() {
3090	return type == BuiltinOptions_TopKV2Options ?
3091	reinterpret_cast<tflite::TopKV2OptionsT >(value) : nullptr*;
3092	}
3093	const tflite::TopKV2OptionsT AsTopKV2Options() const* {
3094	return type == BuiltinOptions_TopKV2Options ?
3095	reinterpret_cast<const tflite::TopKV2OptionsT >(value) : nullptr*;
3096	}
3097	tflite::SplitOptionsT *AsSplitOptions() {
3098	return type == BuiltinOptions_SplitOptions ?
3099	reinterpret_cast<tflite::SplitOptionsT >(value) : nullptr*;
3100	}
3101	const tflite::SplitOptionsT AsSplitOptions() const* {
3102	return type == BuiltinOptions_SplitOptions ?
3103	reinterpret_cast<const tflite::SplitOptionsT >(value) : nullptr*;
3104	}
3105	tflite::LogSoftmaxOptionsT *AsLogSoftmaxOptions() {
3106	return type == BuiltinOptions_LogSoftmaxOptions ?
3107	reinterpret_cast<tflite::LogSoftmaxOptionsT >(value) : nullptr*;
3108	}
3109	const tflite::LogSoftmaxOptionsT AsLogSoftmaxOptions() const* {
3110	return type == BuiltinOptions_LogSoftmaxOptions ?
3111	reinterpret_cast<const tflite::LogSoftmaxOptionsT >(value) : nullptr*;
3112	}
3113	tflite::CastOptionsT *AsCastOptions() {
3114	return type == BuiltinOptions_CastOptions ?
3115	reinterpret_cast<tflite::CastOptionsT >(value) : nullptr*;
3116	}
3117	const tflite::CastOptionsT AsCastOptions() const* {
3118	return type == BuiltinOptions_CastOptions ?
3119	reinterpret_cast<const tflite::CastOptionsT >(value) : nullptr*;
3120	}
3121	tflite::DequantizeOptionsT *AsDequantizeOptions() {
3122	return type == BuiltinOptions_DequantizeOptions ?
3123	reinterpret_cast<tflite::DequantizeOptionsT >(value) : nullptr*;
3124	}
3125	const tflite::DequantizeOptionsT AsDequantizeOptions() const* {
3126	return type == BuiltinOptions_DequantizeOptions ?
3127	reinterpret_cast<const tflite::DequantizeOptionsT >(value) : nullptr*;
3128	}
3129	tflite::MaximumMinimumOptionsT *AsMaximumMinimumOptions() {
3130	return type == BuiltinOptions_MaximumMinimumOptions ?
3131	reinterpret_cast<tflite::MaximumMinimumOptionsT >(value) : nullptr*;
3132	}
3133	const tflite::MaximumMinimumOptionsT AsMaximumMinimumOptions() const* {
3134	return type == BuiltinOptions_MaximumMinimumOptions ?
3135	reinterpret_cast<const tflite::MaximumMinimumOptionsT >(value) : nullptr*;
3136	}
3137	tflite::ArgMaxOptionsT *AsArgMaxOptions() {
3138	return type == BuiltinOptions_ArgMaxOptions ?
3139	reinterpret_cast<tflite::ArgMaxOptionsT >(value) : nullptr*;
3140	}
3141	const tflite::ArgMaxOptionsT AsArgMaxOptions() const* {
3142	return type == BuiltinOptions_ArgMaxOptions ?
3143	reinterpret_cast<const tflite::ArgMaxOptionsT >(value) : nullptr*;
3144	}
3145	tflite::LessOptionsT *AsLessOptions() {
3146	return type == BuiltinOptions_LessOptions ?
3147	reinterpret_cast<tflite::LessOptionsT >(value) : nullptr*;
3148	}
3149	const tflite::LessOptionsT AsLessOptions() const* {
3150	return type == BuiltinOptions_LessOptions ?
3151	reinterpret_cast<const tflite::LessOptionsT >(value) : nullptr*;
3152	}
3153	tflite::NegOptionsT *AsNegOptions() {
3154	return type == BuiltinOptions_NegOptions ?
3155	reinterpret_cast<tflite::NegOptionsT >(value) : nullptr*;
3156	}
3157	const tflite::NegOptionsT AsNegOptions() const* {
3158	return type == BuiltinOptions_NegOptions ?
3159	reinterpret_cast<const tflite::NegOptionsT >(value) : nullptr*;
3160	}
3161	tflite::PadV2OptionsT *AsPadV2Options() {
3162	return type == BuiltinOptions_PadV2Options ?
3163	reinterpret_cast<tflite::PadV2OptionsT >(value) : nullptr*;
3164	}
3165	const tflite::PadV2OptionsT AsPadV2Options() const* {
3166	return type == BuiltinOptions_PadV2Options ?
3167	reinterpret_cast<const tflite::PadV2OptionsT >(value) : nullptr*;
3168	}
3169	tflite::GreaterOptionsT *AsGreaterOptions() {
3170	return type == BuiltinOptions_GreaterOptions ?
3171	reinterpret_cast<tflite::GreaterOptionsT >(value) : nullptr*;
3172	}
3173	const tflite::GreaterOptionsT AsGreaterOptions() const* {
3174	return type == BuiltinOptions_GreaterOptions ?
3175	reinterpret_cast<const tflite::GreaterOptionsT >(value) : nullptr*;
3176	}
3177	tflite::GreaterEqualOptionsT *AsGreaterEqualOptions() {
3178	return type == BuiltinOptions_GreaterEqualOptions ?
3179	reinterpret_cast<tflite::GreaterEqualOptionsT >(value) : nullptr*;
3180	}
3181	const tflite::GreaterEqualOptionsT AsGreaterEqualOptions() const* {
3182	return type == BuiltinOptions_GreaterEqualOptions ?
3183	reinterpret_cast<const tflite::GreaterEqualOptionsT >(value) : nullptr*;
3184	}
3185	tflite::LessEqualOptionsT *AsLessEqualOptions() {
3186	return type == BuiltinOptions_LessEqualOptions ?
3187	reinterpret_cast<tflite::LessEqualOptionsT >(value) : nullptr*;
3188	}
3189	const tflite::LessEqualOptionsT AsLessEqualOptions() const* {
3190	return type == BuiltinOptions_LessEqualOptions ?
3191	reinterpret_cast<const tflite::LessEqualOptionsT >(value) : nullptr*;
3192	}
3193	tflite::SelectOptionsT *AsSelectOptions() {
3194	return type == BuiltinOptions_SelectOptions ?
3195	reinterpret_cast<tflite::SelectOptionsT >(value) : nullptr*;
3196	}
3197	const tflite::SelectOptionsT AsSelectOptions() const* {
3198	return type == BuiltinOptions_SelectOptions ?
3199	reinterpret_cast<const tflite::SelectOptionsT >(value) : nullptr*;
3200	}
3201	tflite::SliceOptionsT *AsSliceOptions() {
3202	return type == BuiltinOptions_SliceOptions ?
3203	reinterpret_cast<tflite::SliceOptionsT >(value) : nullptr*;
3204	}
3205	const tflite::SliceOptionsT AsSliceOptions() const* {
3206	return type == BuiltinOptions_SliceOptions ?
3207	reinterpret_cast<const tflite::SliceOptionsT >(value) : nullptr*;
3208	}
3209	tflite::TransposeConvOptionsT *AsTransposeConvOptions() {
3210	return type == BuiltinOptions_TransposeConvOptions ?
3211	reinterpret_cast<tflite::TransposeConvOptionsT >(value) : nullptr*;
3212	}
3213	const tflite::TransposeConvOptionsT AsTransposeConvOptions() const* {
3214	return type == BuiltinOptions_TransposeConvOptions ?
3215	reinterpret_cast<const tflite::TransposeConvOptionsT >(value) : nullptr*;
3216	}
3217	tflite::SparseToDenseOptionsT *AsSparseToDenseOptions() {
3218	return type == BuiltinOptions_SparseToDenseOptions ?
3219	reinterpret_cast<tflite::SparseToDenseOptionsT >(value) : nullptr*;
3220	}
3221	const tflite::SparseToDenseOptionsT AsSparseToDenseOptions() const* {
3222	return type == BuiltinOptions_SparseToDenseOptions ?
3223	reinterpret_cast<const tflite::SparseToDenseOptionsT >(value) : nullptr*;
3224	}
3225	tflite::TileOptionsT *AsTileOptions() {
3226	return type == BuiltinOptions_TileOptions ?
3227	reinterpret_cast<tflite::TileOptionsT >(value) : nullptr*;
3228	}
3229	const tflite::TileOptionsT AsTileOptions() const* {
3230	return type == BuiltinOptions_TileOptions ?
3231	reinterpret_cast<const tflite::TileOptionsT >(value) : nullptr*;
3232	}
3233	tflite::ExpandDimsOptionsT *AsExpandDimsOptions() {
3234	return type == BuiltinOptions_ExpandDimsOptions ?
3235	reinterpret_cast<tflite::ExpandDimsOptionsT >(value) : nullptr*;
3236	}
3237	const tflite::ExpandDimsOptionsT AsExpandDimsOptions() const* {
3238	return type == BuiltinOptions_ExpandDimsOptions ?
3239	reinterpret_cast<const tflite::ExpandDimsOptionsT >(value) : nullptr*;
3240	}
3241	tflite::EqualOptionsT *AsEqualOptions() {
3242	return type == BuiltinOptions_EqualOptions ?
3243	reinterpret_cast<tflite::EqualOptionsT >(value) : nullptr*;
3244	}
3245	const tflite::EqualOptionsT AsEqualOptions() const* {
3246	return type == BuiltinOptions_EqualOptions ?
3247	reinterpret_cast<const tflite::EqualOptionsT >(value) : nullptr*;
3248	}
3249	tflite::NotEqualOptionsT *AsNotEqualOptions() {
3250	return type == BuiltinOptions_NotEqualOptions ?
3251	reinterpret_cast<tflite::NotEqualOptionsT >(value) : nullptr*;
3252	}
3253	const tflite::NotEqualOptionsT AsNotEqualOptions() const* {
3254	return type == BuiltinOptions_NotEqualOptions ?
3255	reinterpret_cast<const tflite::NotEqualOptionsT >(value) : nullptr*;
3256	}
3257	tflite::ShapeOptionsT *AsShapeOptions() {
3258	return type == BuiltinOptions_ShapeOptions ?
3259	reinterpret_cast<tflite::ShapeOptionsT >(value) : nullptr*;
3260	}
3261	const tflite::ShapeOptionsT AsShapeOptions() const* {
3262	return type == BuiltinOptions_ShapeOptions ?
3263	reinterpret_cast<const tflite::ShapeOptionsT >(value) : nullptr*;
3264	}
3265	tflite::PowOptionsT *AsPowOptions() {
3266	return type == BuiltinOptions_PowOptions ?
3267	reinterpret_cast<tflite::PowOptionsT >(value) : nullptr*;
3268	}
3269	const tflite::PowOptionsT AsPowOptions() const* {
3270	return type == BuiltinOptions_PowOptions ?
3271	reinterpret_cast<const tflite::PowOptionsT >(value) : nullptr*;
3272	}
3273	tflite::ArgMinOptionsT *AsArgMinOptions() {
3274	return type == BuiltinOptions_ArgMinOptions ?
3275	reinterpret_cast<tflite::ArgMinOptionsT >(value) : nullptr*;
3276	}
3277	const tflite::ArgMinOptionsT AsArgMinOptions() const* {
3278	return type == BuiltinOptions_ArgMinOptions ?
3279	reinterpret_cast<const tflite::ArgMinOptionsT >(value) : nullptr*;
3280	}
3281	tflite::FakeQuantOptionsT *AsFakeQuantOptions() {
3282	return type == BuiltinOptions_FakeQuantOptions ?
3283	reinterpret_cast<tflite::FakeQuantOptionsT >(value) : nullptr*;
3284	}
3285	const tflite::FakeQuantOptionsT AsFakeQuantOptions() const* {
3286	return type == BuiltinOptions_FakeQuantOptions ?
3287	reinterpret_cast<const tflite::FakeQuantOptionsT >(value) : nullptr*;
3288	}
3289	tflite::PackOptionsT *AsPackOptions() {
3290	return type == BuiltinOptions_PackOptions ?
3291	reinterpret_cast<tflite::PackOptionsT >(value) : nullptr*;
3292	}
3293	const tflite::PackOptionsT AsPackOptions() const* {
3294	return type == BuiltinOptions_PackOptions ?
3295	reinterpret_cast<const tflite::PackOptionsT >(value) : nullptr*;
3296	}
3297	tflite::LogicalOrOptionsT *AsLogicalOrOptions() {
3298	return type == BuiltinOptions_LogicalOrOptions ?
3299	reinterpret_cast<tflite::LogicalOrOptionsT >(value) : nullptr*;
3300	}
3301	const tflite::LogicalOrOptionsT AsLogicalOrOptions() const* {
3302	return type == BuiltinOptions_LogicalOrOptions ?
3303	reinterpret_cast<const tflite::LogicalOrOptionsT >(value) : nullptr*;
3304	}
3305	tflite::OneHotOptionsT *AsOneHotOptions() {
3306	return type == BuiltinOptions_OneHotOptions ?
3307	reinterpret_cast<tflite::OneHotOptionsT >(value) : nullptr*;
3308	}
3309	const tflite::OneHotOptionsT AsOneHotOptions() const* {
3310	return type == BuiltinOptions_OneHotOptions ?
3311	reinterpret_cast<const tflite::OneHotOptionsT >(value) : nullptr*;
3312	}
3313	tflite::LogicalAndOptionsT *AsLogicalAndOptions() {
3314	return type == BuiltinOptions_LogicalAndOptions ?
3315	reinterpret_cast<tflite::LogicalAndOptionsT >(value) : nullptr*;
3316	}
3317	const tflite::LogicalAndOptionsT AsLogicalAndOptions() const* {
3318	return type == BuiltinOptions_LogicalAndOptions ?
3319	reinterpret_cast<const tflite::LogicalAndOptionsT >(value) : nullptr*;
3320	}
3321	tflite::LogicalNotOptionsT *AsLogicalNotOptions() {
3322	return type == BuiltinOptions_LogicalNotOptions ?
3323	reinterpret_cast<tflite::LogicalNotOptionsT >(value) : nullptr*;
3324	}
3325	const tflite::LogicalNotOptionsT AsLogicalNotOptions() const* {
3326	return type == BuiltinOptions_LogicalNotOptions ?
3327	reinterpret_cast<const tflite::LogicalNotOptionsT >(value) : nullptr*;
3328	}
3329	tflite::UnpackOptionsT *AsUnpackOptions() {
3330	return type == BuiltinOptions_UnpackOptions ?
3331	reinterpret_cast<tflite::UnpackOptionsT >(value) : nullptr*;
3332	}
3333	const tflite::UnpackOptionsT AsUnpackOptions() const* {
3334	return type == BuiltinOptions_UnpackOptions ?
3335	reinterpret_cast<const tflite::UnpackOptionsT >(value) : nullptr*;
3336	}
3337	tflite::FloorDivOptionsT *AsFloorDivOptions() {
3338	return type == BuiltinOptions_FloorDivOptions ?
3339	reinterpret_cast<tflite::FloorDivOptionsT >(value) : nullptr*;
3340	}
3341	const tflite::FloorDivOptionsT AsFloorDivOptions() const* {
3342	return type == BuiltinOptions_FloorDivOptions ?
3343	reinterpret_cast<const tflite::FloorDivOptionsT >(value) : nullptr*;
3344	}
3345	tflite::SquareOptionsT *AsSquareOptions() {
3346	return type == BuiltinOptions_SquareOptions ?
3347	reinterpret_cast<tflite::SquareOptionsT >(value) : nullptr*;
3348	}
3349	const tflite::SquareOptionsT AsSquareOptions() const* {
3350	return type == BuiltinOptions_SquareOptions ?
3351	reinterpret_cast<const tflite::SquareOptionsT >(value) : nullptr*;
3352	}
3353	tflite::ZerosLikeOptionsT *AsZerosLikeOptions() {
3354	return type == BuiltinOptions_ZerosLikeOptions ?
3355	reinterpret_cast<tflite::ZerosLikeOptionsT >(value) : nullptr*;
3356	}
3357	const tflite::ZerosLikeOptionsT AsZerosLikeOptions() const* {
3358	return type == BuiltinOptions_ZerosLikeOptions ?
3359	reinterpret_cast<const tflite::ZerosLikeOptionsT >(value) : nullptr*;
3360	}
3361	tflite::FillOptionsT *AsFillOptions() {
3362	return type == BuiltinOptions_FillOptions ?
3363	reinterpret_cast<tflite::FillOptionsT >(value) : nullptr*;
3364	}
3365	const tflite::FillOptionsT AsFillOptions() const* {
3366	return type == BuiltinOptions_FillOptions ?
3367	reinterpret_cast<const tflite::FillOptionsT >(value) : nullptr*;
3368	}
3369	tflite::BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() {
3370	return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
3371	reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
3372	}
3373	const tflite::BidirectionalSequenceLSTMOptionsT AsBidirectionalSequenceLSTMOptions() const* {
3374	return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ?
3375	reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
3376	}
3377	tflite::BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() {
3378	return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
3379	reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT >(value) : nullptr*;
3380	}
3381	const tflite::BidirectionalSequenceRNNOptionsT AsBidirectionalSequenceRNNOptions() const* {
3382	return type == BuiltinOptions_BidirectionalSequenceRNNOptions ?
3383	reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT >(value) : nullptr*;
3384	}
3385	tflite::UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() {
3386	return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
3387	reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
3388	}
3389	const tflite::UnidirectionalSequenceLSTMOptionsT AsUnidirectionalSequenceLSTMOptions() const* {
3390	return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ?
3391	reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT >(value) : nullptr*;
3392	}
3393	tflite::FloorModOptionsT *AsFloorModOptions() {
3394	return type == BuiltinOptions_FloorModOptions ?
3395	reinterpret_cast<tflite::FloorModOptionsT >(value) : nullptr*;
3396	}
3397	const tflite::FloorModOptionsT AsFloorModOptions() const* {
3398	return type == BuiltinOptions_FloorModOptions ?
3399	reinterpret_cast<const tflite::FloorModOptionsT >(value) : nullptr*;
3400	}
3401	tflite::RangeOptionsT *AsRangeOptions() {
3402	return type == BuiltinOptions_RangeOptions ?
3403	reinterpret_cast<tflite::RangeOptionsT >(value) : nullptr*;
3404	}
3405	const tflite::RangeOptionsT AsRangeOptions() const* {
3406	return type == BuiltinOptions_RangeOptions ?
3407	reinterpret_cast<const tflite::RangeOptionsT >(value) : nullptr*;
3408	}
3409	tflite::ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() {
3410	return type == BuiltinOptions_ResizeNearestNeighborOptions ?
3411	reinterpret_cast<tflite::ResizeNearestNeighborOptionsT >(value) : nullptr*;
3412	}
3413	const tflite::ResizeNearestNeighborOptionsT AsResizeNearestNeighborOptions() const* {
3414	return type == BuiltinOptions_ResizeNearestNeighborOptions ?
3415	reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT >(value) : nullptr*;
3416	}
3417	tflite::LeakyReluOptionsT *AsLeakyReluOptions() {
3418	return type == BuiltinOptions_LeakyReluOptions ?
3419	reinterpret_cast<tflite::LeakyReluOptionsT >(value) : nullptr*;
3420	}
3421	const tflite::LeakyReluOptionsT AsLeakyReluOptions() const* {
3422	return type == BuiltinOptions_LeakyReluOptions ?
3423	reinterpret_cast<const tflite::LeakyReluOptionsT >(value) : nullptr*;
3424	}
3425	tflite::SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() {
3426	return type == BuiltinOptions_SquaredDifferenceOptions ?
3427	reinterpret_cast<tflite::SquaredDifferenceOptionsT >(value) : nullptr*;
3428	}
3429	const tflite::SquaredDifferenceOptionsT AsSquaredDifferenceOptions() const* {
3430	return type == BuiltinOptions_SquaredDifferenceOptions ?
3431	reinterpret_cast<const tflite::SquaredDifferenceOptionsT >(value) : nullptr*;
3432	}
3433	tflite::MirrorPadOptionsT *AsMirrorPadOptions() {
3434	return type == BuiltinOptions_MirrorPadOptions ?
3435	reinterpret_cast<tflite::MirrorPadOptionsT >(value) : nullptr*;
3436	}
3437	const tflite::MirrorPadOptionsT AsMirrorPadOptions() const* {
3438	return type == BuiltinOptions_MirrorPadOptions ?
3439	reinterpret_cast<const tflite::MirrorPadOptionsT >(value) : nullptr*;
3440	}
3441	tflite::AbsOptionsT *AsAbsOptions() {
3442	return type == BuiltinOptions_AbsOptions ?
3443	reinterpret_cast<tflite::AbsOptionsT >(value) : nullptr*;
3444	}
3445	const tflite::AbsOptionsT AsAbsOptions() const* {
3446	return type == BuiltinOptions_AbsOptions ?
3447	reinterpret_cast<const tflite::AbsOptionsT >(value) : nullptr*;
3448	}
3449	tflite::SplitVOptionsT *AsSplitVOptions() {
3450	return type == BuiltinOptions_SplitVOptions ?
3451	reinterpret_cast<tflite::SplitVOptionsT >(value) : nullptr*;
3452	}
3453	const tflite::SplitVOptionsT AsSplitVOptions() const* {
3454	return type == BuiltinOptions_SplitVOptions ?
3455	reinterpret_cast<const tflite::SplitVOptionsT >(value) : nullptr*;
3456	}
3457	tflite::UniqueOptionsT *AsUniqueOptions() {
3458	return type == BuiltinOptions_UniqueOptions ?
3459	reinterpret_cast<tflite::UniqueOptionsT >(value) : nullptr*;
3460	}
3461	const tflite::UniqueOptionsT AsUniqueOptions() const* {
3462	return type == BuiltinOptions_UniqueOptions ?
3463	reinterpret_cast<const tflite::UniqueOptionsT >(value) : nullptr*;
3464	}
3465	tflite::ReverseV2OptionsT *AsReverseV2Options() {
3466	return type == BuiltinOptions_ReverseV2Options ?
3467	reinterpret_cast<tflite::ReverseV2OptionsT >(value) : nullptr*;
3468	}
3469	const tflite::ReverseV2OptionsT AsReverseV2Options() const* {
3470	return type == BuiltinOptions_ReverseV2Options ?
3471	reinterpret_cast<const tflite::ReverseV2OptionsT >(value) : nullptr*;
3472	}
3473	tflite::AddNOptionsT *AsAddNOptions() {
3474	return type == BuiltinOptions_AddNOptions ?
3475	reinterpret_cast<tflite::AddNOptionsT >(value) : nullptr*;
3476	}
3477	const tflite::AddNOptionsT AsAddNOptions() const* {
3478	return type == BuiltinOptions_AddNOptions ?
3479	reinterpret_cast<const tflite::AddNOptionsT >(value) : nullptr*;
3480	}
3481	tflite::GatherNdOptionsT *AsGatherNdOptions() {
3482	return type == BuiltinOptions_GatherNdOptions ?
3483	reinterpret_cast<tflite::GatherNdOptionsT >(value) : nullptr*;
3484	}
3485	const tflite::GatherNdOptionsT AsGatherNdOptions() const* {
3486	return type == BuiltinOptions_GatherNdOptions ?
3487	reinterpret_cast<const tflite::GatherNdOptionsT >(value) : nullptr*;
3488	}
3489	tflite::CosOptionsT *AsCosOptions() {
3490	return type == BuiltinOptions_CosOptions ?
3491	reinterpret_cast<tflite::CosOptionsT >(value) : nullptr*;
3492	}
3493	const tflite::CosOptionsT AsCosOptions() const* {
3494	return type == BuiltinOptions_CosOptions ?
3495	reinterpret_cast<const tflite::CosOptionsT >(value) : nullptr*;
3496	}
3497	tflite::WhereOptionsT *AsWhereOptions() {
3498	return type == BuiltinOptions_WhereOptions ?
3499	reinterpret_cast<tflite::WhereOptionsT >(value) : nullptr*;
3500	}
3501	const tflite::WhereOptionsT AsWhereOptions() const* {
3502	return type == BuiltinOptions_WhereOptions ?
3503	reinterpret_cast<const tflite::WhereOptionsT >(value) : nullptr*;
3504	}
3505	tflite::RankOptionsT *AsRankOptions() {
3506	return type == BuiltinOptions_RankOptions ?
3507	reinterpret_cast<tflite::RankOptionsT >(value) : nullptr*;
3508	}
3509	const tflite::RankOptionsT AsRankOptions() const* {
3510	return type == BuiltinOptions_RankOptions ?
3511	reinterpret_cast<const tflite::RankOptionsT >(value) : nullptr*;
3512	}
3513	tflite::ReverseSequenceOptionsT *AsReverseSequenceOptions() {
3514	return type == BuiltinOptions_ReverseSequenceOptions ?
3515	reinterpret_cast<tflite::ReverseSequenceOptionsT >(value) : nullptr*;
3516	}
3517	const tflite::ReverseSequenceOptionsT AsReverseSequenceOptions() const* {
3518	return type == BuiltinOptions_ReverseSequenceOptions ?
3519	reinterpret_cast<const tflite::ReverseSequenceOptionsT >(value) : nullptr*;
3520	}
3521	tflite::MatrixDiagOptionsT *AsMatrixDiagOptions() {
3522	return type == BuiltinOptions_MatrixDiagOptions ?
3523	reinterpret_cast<tflite::MatrixDiagOptionsT >(value) : nullptr*;
3524	}
3525	const tflite::MatrixDiagOptionsT AsMatrixDiagOptions() const* {
3526	return type == BuiltinOptions_MatrixDiagOptions ?
3527	reinterpret_cast<const tflite::MatrixDiagOptionsT >(value) : nullptr*;
3528	}
3529	tflite::QuantizeOptionsT *AsQuantizeOptions() {
3530	return type == BuiltinOptions_QuantizeOptions ?
3531	reinterpret_cast<tflite::QuantizeOptionsT >(value) : nullptr*;
3532	}
3533	const tflite::QuantizeOptionsT AsQuantizeOptions() const* {
3534	return type == BuiltinOptions_QuantizeOptions ?
3535	reinterpret_cast<const tflite::QuantizeOptionsT >(value) : nullptr*;
3536	}
3537	tflite::MatrixSetDiagOptionsT *AsMatrixSetDiagOptions() {
3538	return type == BuiltinOptions_MatrixSetDiagOptions ?
3539	reinterpret_cast<tflite::MatrixSetDiagOptionsT >(value) : nullptr*;
3540	}
3541	const tflite::MatrixSetDiagOptionsT AsMatrixSetDiagOptions() const* {
3542	return type == BuiltinOptions_MatrixSetDiagOptions ?
3543	reinterpret_cast<const tflite::MatrixSetDiagOptionsT >(value) : nullptr*;
3544	}
3545	tflite::HardSwishOptionsT *AsHardSwishOptions() {
3546	return type == BuiltinOptions_HardSwishOptions ?
3547	reinterpret_cast<tflite::HardSwishOptionsT >(value) : nullptr*;
3548	}
3549	const tflite::HardSwishOptionsT AsHardSwishOptions() const* {
3550	return type == BuiltinOptions_HardSwishOptions ?
3551	reinterpret_cast<const tflite::HardSwishOptionsT >(value) : nullptr*;
3552	}
3553	tflite::IfOptionsT *AsIfOptions() {
3554	return type == BuiltinOptions_IfOptions ?
3555	reinterpret_cast<tflite::IfOptionsT >(value) : nullptr*;
3556	}
3557	const tflite::IfOptionsT AsIfOptions() const* {
3558	return type == BuiltinOptions_IfOptions ?
3559	reinterpret_cast<const tflite::IfOptionsT >(value) : nullptr*;
3560	}
3561	tflite::WhileOptionsT *AsWhileOptions() {
3562	return type == BuiltinOptions_WhileOptions ?
3563	reinterpret_cast<tflite::WhileOptionsT >(value) : nullptr*;
3564	}
3565	const tflite::WhileOptionsT AsWhileOptions() const* {
3566	return type == BuiltinOptions_WhileOptions ?
3567	reinterpret_cast<const tflite::WhileOptionsT >(value) : nullptr*;
3568	}
3569	tflite::DepthToSpaceOptionsT *AsDepthToSpaceOptions() {
3570	return type == BuiltinOptions_DepthToSpaceOptions ?
3571	reinterpret_cast<tflite::DepthToSpaceOptionsT >(value) : nullptr*;
3572	}
3573	const tflite::DepthToSpaceOptionsT AsDepthToSpaceOptions() const* {
3574	return type == BuiltinOptions_DepthToSpaceOptions ?
3575	reinterpret_cast<const tflite::DepthToSpaceOptionsT >(value) : nullptr*;
3576	}
3577	tflite::NonMaxSuppressionV4OptionsT *AsNonMaxSuppressionV4Options() {
3578	return type == BuiltinOptions_NonMaxSuppressionV4Options ?
3579	reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT >(value) : nullptr*;
3580	}
3581	const tflite::NonMaxSuppressionV4OptionsT AsNonMaxSuppressionV4Options() const* {
3582	return type == BuiltinOptions_NonMaxSuppressionV4Options ?
3583	reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT >(value) : nullptr*;
3584	}
3585	tflite::NonMaxSuppressionV5OptionsT *AsNonMaxSuppressionV5Options() {
3586	return type == BuiltinOptions_NonMaxSuppressionV5Options ?
3587	reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT >(value) : nullptr*;
3588	}
3589	const tflite::NonMaxSuppressionV5OptionsT AsNonMaxSuppressionV5Options() const* {
3590	return type == BuiltinOptions_NonMaxSuppressionV5Options ?
3591	reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT >(value) : nullptr*;
3592	}
3593	tflite::ScatterNdOptionsT *AsScatterNdOptions() {
3594	return type == BuiltinOptions_ScatterNdOptions ?
3595	reinterpret_cast<tflite::ScatterNdOptionsT >(value) : nullptr*;
3596	}
3597	const tflite::ScatterNdOptionsT AsScatterNdOptions() const* {
3598	return type == BuiltinOptions_ScatterNdOptions ?
3599	reinterpret_cast<const tflite::ScatterNdOptionsT >(value) : nullptr*;
3600	}
3601	tflite::SelectV2OptionsT *AsSelectV2Options() {
3602	return type == BuiltinOptions_SelectV2Options ?
3603	reinterpret_cast<tflite::SelectV2OptionsT >(value) : nullptr*;
3604	}
3605	const tflite::SelectV2OptionsT AsSelectV2Options() const* {
3606	return type == BuiltinOptions_SelectV2Options ?
3607	reinterpret_cast<const tflite::SelectV2OptionsT >(value) : nullptr*;
3608	}
3609	tflite::DensifyOptionsT *AsDensifyOptions() {
3610	return type == BuiltinOptions_DensifyOptions ?
3611	reinterpret_cast<tflite::DensifyOptionsT >(value) : nullptr*;
3612	}
3613	const tflite::DensifyOptionsT AsDensifyOptions() const* {
3614	return type == BuiltinOptions_DensifyOptions ?
3615	reinterpret_cast<const tflite::DensifyOptionsT >(value) : nullptr*;
3616	}
3617	tflite::SegmentSumOptionsT *AsSegmentSumOptions() {
3618	return type == BuiltinOptions_SegmentSumOptions ?
3619	reinterpret_cast<tflite::SegmentSumOptionsT >(value) : nullptr*;
3620	}
3621	const tflite::SegmentSumOptionsT AsSegmentSumOptions() const* {
3622	return type == BuiltinOptions_SegmentSumOptions ?
3623	reinterpret_cast<const tflite::SegmentSumOptionsT >(value) : nullptr*;
3624	}
3625	tflite::BatchMatMulOptionsT *AsBatchMatMulOptions() {
3626	return type == BuiltinOptions_BatchMatMulOptions ?
3627	reinterpret_cast<tflite::BatchMatMulOptionsT >(value) : nullptr*;
3628	}
3629	const tflite::BatchMatMulOptionsT AsBatchMatMulOptions() const* {
3630	return type == BuiltinOptions_BatchMatMulOptions ?
3631	reinterpret_cast<const tflite::BatchMatMulOptionsT >(value) : nullptr*;
3632	}
3633	tflite::CumsumOptionsT *AsCumsumOptions() {
3634	return type == BuiltinOptions_CumsumOptions ?
3635	reinterpret_cast<tflite::CumsumOptionsT >(value) : nullptr*;
3636	}
3637	const tflite::CumsumOptionsT AsCumsumOptions() const* {
3638	return type == BuiltinOptions_CumsumOptions ?
3639	reinterpret_cast<const tflite::CumsumOptionsT >(value) : nullptr*;
3640	}
3641	tflite::CallOnceOptionsT *AsCallOnceOptions() {
3642	return type == BuiltinOptions_CallOnceOptions ?
3643	reinterpret_cast<tflite::CallOnceOptionsT >(value) : nullptr*;
3644	}
3645	const tflite::CallOnceOptionsT AsCallOnceOptions() const* {
3646	return type == BuiltinOptions_CallOnceOptions ?
3647	reinterpret_cast<const tflite::CallOnceOptionsT >(value) : nullptr*;
3648	}
3649	tflite::BroadcastToOptionsT *AsBroadcastToOptions() {
3650	return type == BuiltinOptions_BroadcastToOptions ?
3651	reinterpret_cast<tflite::BroadcastToOptionsT >(value) : nullptr*;
3652	}
3653	const tflite::BroadcastToOptionsT AsBroadcastToOptions() const* {
3654	return type == BuiltinOptions_BroadcastToOptions ?
3655	reinterpret_cast<const tflite::BroadcastToOptionsT >(value) : nullptr*;
3656	}
3657	tflite::Rfft2dOptionsT *AsRfft2dOptions() {
3658	return type == BuiltinOptions_Rfft2dOptions ?
3659	reinterpret_cast<tflite::Rfft2dOptionsT >(value) : nullptr*;
3660	}
3661	const tflite::Rfft2dOptionsT AsRfft2dOptions() const* {
3662	return type == BuiltinOptions_Rfft2dOptions ?
3663	reinterpret_cast<const tflite::Rfft2dOptionsT >(value) : nullptr*;
3664	}
3665	tflite::Conv3DOptionsT *AsConv3DOptions() {
3666	return type == BuiltinOptions_Conv3DOptions ?
3667	reinterpret_cast<tflite::Conv3DOptionsT >(value) : nullptr*;
3668	}
3669	const tflite::Conv3DOptionsT AsConv3DOptions() const* {
3670	return type == BuiltinOptions_Conv3DOptions ?
3671	reinterpret_cast<const tflite::Conv3DOptionsT >(value) : nullptr*;
3672	}
3673	tflite::HashtableOptionsT *AsHashtableOptions() {
3674	return type == BuiltinOptions_HashtableOptions ?
3675	reinterpret_cast<tflite::HashtableOptionsT >(value) : nullptr*;
3676	}
3677	const tflite::HashtableOptionsT AsHashtableOptions() const* {
3678	return type == BuiltinOptions_HashtableOptions ?
3679	reinterpret_cast<const tflite::HashtableOptionsT >(value) : nullptr*;
3680	}
3681	tflite::HashtableFindOptionsT *AsHashtableFindOptions() {
3682	return type == BuiltinOptions_HashtableFindOptions ?
3683	reinterpret_cast<tflite::HashtableFindOptionsT >(value) : nullptr*;
3684	}
3685	const tflite::HashtableFindOptionsT AsHashtableFindOptions() const* {
3686	return type == BuiltinOptions_HashtableFindOptions ?
3687	reinterpret_cast<const tflite::HashtableFindOptionsT >(value) : nullptr*;
3688	}
3689	tflite::HashtableImportOptionsT *AsHashtableImportOptions() {
3690	return type == BuiltinOptions_HashtableImportOptions ?
3691	reinterpret_cast<tflite::HashtableImportOptionsT >(value) : nullptr*;
3692	}
3693	const tflite::HashtableImportOptionsT AsHashtableImportOptions() const* {
3694	return type == BuiltinOptions_HashtableImportOptions ?
3695	reinterpret_cast<const tflite::HashtableImportOptionsT >(value) : nullptr*;
3696	}
3697	tflite::HashtableSizeOptionsT *AsHashtableSizeOptions() {
3698	return type == BuiltinOptions_HashtableSizeOptions ?
3699	reinterpret_cast<tflite::HashtableSizeOptionsT >(value) : nullptr*;
3700	}
3701	const tflite::HashtableSizeOptionsT AsHashtableSizeOptions() const* {
3702	return type == BuiltinOptions_HashtableSizeOptions ?
3703	reinterpret_cast<const tflite::HashtableSizeOptionsT >(value) : nullptr*;
3704	}
3705	tflite::VarHandleOptionsT *AsVarHandleOptions() {
3706	return type == BuiltinOptions_VarHandleOptions ?
3707	reinterpret_cast<tflite::VarHandleOptionsT >(value) : nullptr*;
3708	}
3709	const tflite::VarHandleOptionsT AsVarHandleOptions() const* {
3710	return type == BuiltinOptions_VarHandleOptions ?
3711	reinterpret_cast<const tflite::VarHandleOptionsT >(value) : nullptr*;
3712	}
3713	tflite::ReadVariableOptionsT *AsReadVariableOptions() {
3714	return type == BuiltinOptions_ReadVariableOptions ?
3715	reinterpret_cast<tflite::ReadVariableOptionsT >(value) : nullptr*;
3716	}
3717	const tflite::ReadVariableOptionsT AsReadVariableOptions() const* {
3718	return type == BuiltinOptions_ReadVariableOptions ?
3719	reinterpret_cast<const tflite::ReadVariableOptionsT >(value) : nullptr*;
3720	}
3721	tflite::AssignVariableOptionsT *AsAssignVariableOptions() {
3722	return type == BuiltinOptions_AssignVariableOptions ?
3723	reinterpret_cast<tflite::AssignVariableOptionsT >(value) : nullptr*;
3724	}
3725	const tflite::AssignVariableOptionsT AsAssignVariableOptions() const* {
3726	return type == BuiltinOptions_AssignVariableOptions ?
3727	reinterpret_cast<const tflite::AssignVariableOptionsT >(value) : nullptr*;
3728	}
3729	tflite::RandomOptionsT *AsRandomOptions() {
3730	return type == BuiltinOptions_RandomOptions ?
3731	reinterpret_cast<tflite::RandomOptionsT >(value) : nullptr*;
3732	}
3733	const tflite::RandomOptionsT AsRandomOptions() const* {
3734	return type == BuiltinOptions_RandomOptions ?
3735	reinterpret_cast<const tflite::RandomOptionsT >(value) : nullptr*;
3736	}
3737	tflite::BucketizeOptionsT *AsBucketizeOptions() {
3738	return type == BuiltinOptions_BucketizeOptions ?
3739	reinterpret_cast<tflite::BucketizeOptionsT >(value) : nullptr*;
3740	}
3741	const tflite::BucketizeOptionsT AsBucketizeOptions() const* {
3742	return type == BuiltinOptions_BucketizeOptions ?
3743	reinterpret_cast<const tflite::BucketizeOptionsT >(value) : nullptr*;
3744	}
3745	tflite::GeluOptionsT *AsGeluOptions() {
3746	return type == BuiltinOptions_GeluOptions ?
3747	reinterpret_cast<tflite::GeluOptionsT >(value) : nullptr*;
3748	}
3749	const tflite::GeluOptionsT AsGeluOptions() const* {
3750	return type == BuiltinOptions_GeluOptions ?
3751	reinterpret_cast<const tflite::GeluOptionsT >(value) : nullptr*;
3752	}
3753	tflite::DynamicUpdateSliceOptionsT *AsDynamicUpdateSliceOptions() {
3754	return type == BuiltinOptions_DynamicUpdateSliceOptions ?
3755	reinterpret_cast<tflite::DynamicUpdateSliceOptionsT >(value) : nullptr*;
3756	}
3757	const tflite::DynamicUpdateSliceOptionsT AsDynamicUpdateSliceOptions() const* {
3758	return type == BuiltinOptions_DynamicUpdateSliceOptions ?
3759	reinterpret_cast<const tflite::DynamicUpdateSliceOptionsT >(value) : nullptr*;
3760	}
3761	tflite::UnsortedSegmentProdOptionsT *AsUnsortedSegmentProdOptions() {
3762	return type == BuiltinOptions_UnsortedSegmentProdOptions ?
3763	reinterpret_cast<tflite::UnsortedSegmentProdOptionsT >(value) : nullptr*;
3764	}
3765	const tflite::UnsortedSegmentProdOptionsT AsUnsortedSegmentProdOptions() const* {
3766	return type == BuiltinOptions_UnsortedSegmentProdOptions ?
3767	reinterpret_cast<const tflite::UnsortedSegmentProdOptionsT >(value) : nullptr*;
3768	}
3769	tflite::UnsortedSegmentMaxOptionsT *AsUnsortedSegmentMaxOptions() {
3770	return type == BuiltinOptions_UnsortedSegmentMaxOptions ?
3771	reinterpret_cast<tflite::UnsortedSegmentMaxOptionsT >(value) : nullptr*;
3772	}
3773	const tflite::UnsortedSegmentMaxOptionsT AsUnsortedSegmentMaxOptions() const* {
3774	return type == BuiltinOptions_UnsortedSegmentMaxOptions ?
3775	reinterpret_cast<const tflite::UnsortedSegmentMaxOptionsT >(value) : nullptr*;
3776	}
3777	tflite::UnsortedSegmentMinOptionsT *AsUnsortedSegmentMinOptions() {
3778	return type == BuiltinOptions_UnsortedSegmentMinOptions ?
3779	reinterpret_cast<tflite::UnsortedSegmentMinOptionsT >(value) : nullptr*;
3780	}
3781	const tflite::UnsortedSegmentMinOptionsT AsUnsortedSegmentMinOptions() const* {
3782	return type == BuiltinOptions_UnsortedSegmentMinOptions ?
3783	reinterpret_cast<const tflite::UnsortedSegmentMinOptionsT >(value) : nullptr*;
3784	}
3785	tflite::UnsortedSegmentSumOptionsT *AsUnsortedSegmentSumOptions() {
3786	return type == BuiltinOptions_UnsortedSegmentSumOptions ?
3787	reinterpret_cast<tflite::UnsortedSegmentSumOptionsT >(value) : nullptr*;
3788	}
3789	const tflite::UnsortedSegmentSumOptionsT AsUnsortedSegmentSumOptions() const* {
3790	return type == BuiltinOptions_UnsortedSegmentSumOptions ?
3791	reinterpret_cast<const tflite::UnsortedSegmentSumOptionsT >(value) : nullptr*;
3792	}
3793	tflite::ATan2OptionsT *AsATan2Options() {
3794	return type == BuiltinOptions_ATan2Options ?
3795	reinterpret_cast<tflite::ATan2OptionsT >(value) : nullptr*;
3796	}
3797	const tflite::ATan2OptionsT AsATan2Options() const* {
3798	return type == BuiltinOptions_ATan2Options ?
3799	reinterpret_cast<const tflite::ATan2OptionsT >(value) : nullptr*;
3800	}
3801	tflite::SignOptionsT *AsSignOptions() {
3802	return type == BuiltinOptions_SignOptions ?
3803	reinterpret_cast<tflite::SignOptionsT >(value) : nullptr*;
3804	}
3805	const tflite::SignOptionsT AsSignOptions() const* {
3806	return type == BuiltinOptions_SignOptions ?
3807	reinterpret_cast<const tflite::SignOptionsT >(value) : nullptr*;
3808	}
3809	};
3810
3811	bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
3812	bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types);
3813
3814	enum Padding : int8_t {
3815	Padding_SAME = `0`,
3816	Padding_VALID = `1`,
3817	Padding_MIN = Padding_SAME,
3818	Padding_MAX = Padding_VALID
3819	};
3820
3821	inline const Padding (&EnumValuesPadding())[`2`] {
3822	static const Padding values[] = {
3823	Padding_SAME,
3824	Padding_VALID
3825	};
3826	return values;
3827	}
3828
3829	inline const char * const *EnumNamesPadding() {
3830	static const char * const names[`3`] = {
3831	"SAME",
3832	"VALID",
3833	nullptr
3834	};
3835	return names;
3836	}
3837
3838	inline const char *EnumNamePadding(Padding e) {
3839	if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return "";
3840	const size_t index = static_cast<size_t>(e);
3841	return EnumNamesPadding()[index];
3842	}
3843
3844	enum ActivationFunctionType : int8_t {
3845	ActivationFunctionType_NONE = `0`,
3846	ActivationFunctionType_RELU = `1`,
3847	ActivationFunctionType_RELU_N1_TO_1 = `2`,
3848	ActivationFunctionType_RELU6 = `3`,
3849	ActivationFunctionType_TANH = `4`,
3850	ActivationFunctionType_SIGN_BIT = `5`,
3851	ActivationFunctionType_MIN = ActivationFunctionType_NONE,
3852	ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT
3853	};
3854
3855	inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[`6`] {
3856	static const ActivationFunctionType values[] = {
3857	ActivationFunctionType_NONE,
3858	ActivationFunctionType_RELU,
3859	ActivationFunctionType_RELU_N1_TO_1,
3860	ActivationFunctionType_RELU6,
3861	ActivationFunctionType_TANH,
3862	ActivationFunctionType_SIGN_BIT
3863	};
3864	return values;
3865	}
3866
3867	inline const char * const *EnumNamesActivationFunctionType() {
3868	static const char * const names[`7`] = {
3869	"NONE",
3870	"RELU",
3871	"RELU_N1_TO_1",
3872	"RELU6",
3873	"TANH",
3874	"SIGN_BIT",
3875	nullptr
3876	};
3877	return names;
3878	}
3879
3880	inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) {
3881	if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return "";
3882	const size_t index = static_cast<size_t>(e);
3883	return EnumNamesActivationFunctionType()[index];
3884	}
3885
3886	enum LSHProjectionType : int8_t {
3887	LSHProjectionType_UNKNOWN = `0`,
3888	LSHProjectionType_SPARSE = `1`,
3889	LSHProjectionType_DENSE = `2`,
3890	LSHProjectionType_MIN = LSHProjectionType_UNKNOWN,
3891	LSHProjectionType_MAX = LSHProjectionType_DENSE
3892	};
3893
3894	inline const LSHProjectionType (&EnumValuesLSHProjectionType())[`3`] {
3895	static const LSHProjectionType values[] = {
3896	LSHProjectionType_UNKNOWN,
3897	LSHProjectionType_SPARSE,
3898	LSHProjectionType_DENSE
3899	};
3900	return values;
3901	}
3902
3903	inline const char * const *EnumNamesLSHProjectionType() {
3904	static const char * const names[`4`] = {
3905	"UNKNOWN",
3906	"SPARSE",
3907	"DENSE",
3908	nullptr
3909	};
3910	return names;
3911	}
3912
3913	inline const char *EnumNameLSHProjectionType(LSHProjectionType e) {
3914	if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return "";
3915	const size_t index = static_cast<size_t>(e);
3916	return EnumNamesLSHProjectionType()[index];
3917	}
3918
3919	enum FullyConnectedOptionsWeightsFormat : int8_t {
3920	FullyConnectedOptionsWeightsFormat_DEFAULT = `0`,
3921	FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = `1`,
3922	FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT,
3923	FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
3924	};
3925
3926	inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[`2`] {
3927	static const FullyConnectedOptionsWeightsFormat values[] = {
3928	FullyConnectedOptionsWeightsFormat_DEFAULT,
3929	FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
3930	};
3931	return values;
3932	}
3933
3934	inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() {
3935	static const char * const names[`3`] = {
3936	"DEFAULT",
3937	"SHUFFLED4x16INT8",
3938	nullptr
3939	};
3940	return names;
3941	}
3942
3943	inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) {
3944	if (flatbuffers::IsOutRange(e, FullyConnectedOptionsWeightsFormat_DEFAULT, FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8)) return "";
3945	const size_t index = static_cast<size_t>(e);
3946	return EnumNamesFullyConnectedOptionsWeightsFormat()[index];
3947	}
3948
3949	enum LSTMKernelType : int8_t {
3950	LSTMKernelType_FULL = `0`,
3951	LSTMKernelType_BASIC = `1`,
3952	LSTMKernelType_MIN = LSTMKernelType_FULL,
3953	LSTMKernelType_MAX = LSTMKernelType_BASIC
3954	};
3955
3956	inline const LSTMKernelType (&EnumValuesLSTMKernelType())[`2`] {
3957	static const LSTMKernelType values[] = {
3958	LSTMKernelType_FULL,
3959	LSTMKernelType_BASIC
3960	};
3961	return values;
3962	}
3963
3964	inline const char * const *EnumNamesLSTMKernelType() {
3965	static const char * const names[`3`] = {
3966	"FULL",
3967	"BASIC",
3968	nullptr
3969	};
3970	return names;
3971	}
3972
3973	inline const char *EnumNameLSTMKernelType(LSTMKernelType e) {
3974	if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return "";
3975	const size_t index = static_cast<size_t>(e);
3976	return EnumNamesLSTMKernelType()[index];
3977	}
3978
3979	enum CombinerType : int8_t {
3980	CombinerType_SUM = `0`,
3981	CombinerType_MEAN = `1`,
3982	CombinerType_SQRTN = `2`,
3983	CombinerType_MIN = CombinerType_SUM,
3984	CombinerType_MAX = CombinerType_SQRTN
3985	};
3986
3987	inline const CombinerType (&EnumValuesCombinerType())[`3`] {
3988	static const CombinerType values[] = {
3989	CombinerType_SUM,
3990	CombinerType_MEAN,
3991	CombinerType_SQRTN
3992	};
3993	return values;
3994	}
3995
3996	inline const char * const *EnumNamesCombinerType() {
3997	static const char * const names[`4`] = {
3998	"SUM",
3999	"MEAN",
4000	"SQRTN",
4001	nullptr
4002	};
4003	return names;
4004	}
4005
4006	inline const char *EnumNameCombinerType(CombinerType e) {
4007	if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return "";
4008	const size_t index = static_cast<size_t>(e);
4009	return EnumNamesCombinerType()[index];
4010	}
4011
4012	enum MirrorPadMode : int8_t {
4013	MirrorPadMode_REFLECT = `0`,
4014	MirrorPadMode_SYMMETRIC = `1`,
4015	MirrorPadMode_MIN = MirrorPadMode_REFLECT,
4016	MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC
4017	};
4018
4019	inline const MirrorPadMode (&EnumValuesMirrorPadMode())[`2`] {
4020	static const MirrorPadMode values[] = {
4021	MirrorPadMode_REFLECT,
4022	MirrorPadMode_SYMMETRIC
4023	};
4024	return values;
4025	}
4026
4027	inline const char * const *EnumNamesMirrorPadMode() {
4028	static const char * const names[`3`] = {
4029	"REFLECT",
4030	"SYMMETRIC",
4031	nullptr
4032	};
4033	return names;
4034	}
4035
4036	inline const char *EnumNameMirrorPadMode(MirrorPadMode e) {
4037	if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return "";
4038	const size_t index = static_cast<size_t>(e);
4039	return EnumNamesMirrorPadMode()[index];
4040	}
4041
4042	enum CustomOptionsFormat : int8_t {
4043	CustomOptionsFormat_FLEXBUFFERS = `0`,
4044	CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS,
4045	CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS
4046	};
4047
4048	inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[`1`] {
4049	static const CustomOptionsFormat values[] = {
4050	CustomOptionsFormat_FLEXBUFFERS
4051	};
4052	return values;
4053	}
4054
4055	inline const char * const *EnumNamesCustomOptionsFormat() {
4056	static const char * const names[`2`] = {
4057	"FLEXBUFFERS",
4058	nullptr
4059	};
4060	return names;
4061	}
4062
4063	inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) {
4064	if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return "";
4065	const size_t index = static_cast<size_t>(e);
4066	return EnumNamesCustomOptionsFormat()[index];
4067	}
4068
4069	struct CustomQuantizationT : public flatbuffers::NativeTable {
4070	typedef CustomQuantization TableType;
4071	std::vector<uint8_t> custom{};
4072	};
4073
4074	struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4075	typedef CustomQuantizationT NativeTableType;
4076	typedef CustomQuantizationBuilder Builder;
4077	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4078	VT_CUSTOM = `4`
4079	};
4080	const flatbuffers::Vector<uint8_t> custom() const* {
4081	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
4082	}
4083	bool Verify(flatbuffers::Verifier &verifier) const {
4084	return VerifyTableStart(verifier) &&
4085	VerifyOffset(verifier, VT_CUSTOM) &&
4086	verifier.VerifyVector(custom()) &&
4087	verifier.EndTable();
4088	}
4089	CustomQuantizationT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4090	void UnPackTo(CustomQuantizationT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4091	static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4092	};
4093
4094	struct CustomQuantizationBuilder {
4095	typedef CustomQuantization Table;
4096	flatbuffers::FlatBufferBuilder &fbb_;
4097	flatbuffers::uoffset_t start_;
4098	void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) {
4099	fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
4100	}
4101	explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4102	: fbb_(_fbb) {
4103	start_ = fbb_.StartTable();
4104	}
4105	flatbuffers::Offset<CustomQuantization> Finish() {
4106	const auto end = fbb_.EndTable(start_);
4107	auto o = flatbuffers::Offset<CustomQuantization>(end);
4108	return o;
4109	}
4110	};
4111
4112	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
4113	flatbuffers::FlatBufferBuilder &_fbb,
4114	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = `0`) {
4115	CustomQuantizationBuilder builder_(_fbb);
4116	builder_.add_custom(custom);
4117	return builder_.Finish();
4118	}
4119
4120	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
4121	flatbuffers::FlatBufferBuilder &_fbb,
4122	const std::vector<uint8_t> custom = nullptr*) {
4123	if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), `16`); }
4124	auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : `0`;
4125	return tflite::CreateCustomQuantization(
4126	_fbb,
4127	custom__);
4128	}
4129
4130	flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4131
4132	struct QuantizationParametersT : public flatbuffers::NativeTable {
4133	typedef QuantizationParameters TableType;
4134	std::vector<float> min{};
4135	std::vector<float> max{};
4136	std::vector<float> scale{};
4137	std::vector<int64_t> zero_point{};
4138	tflite::QuantizationDetailsUnion details{};
4139	int32_t quantized_dimension = `0`;
4140	};
4141
4142	struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4143	typedef QuantizationParametersT NativeTableType;
4144	typedef QuantizationParametersBuilder Builder;
4145	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4146	VT_MIN = `4`,
4147	VT_MAX = `6`,
4148	VT_SCALE = `8`,
4149	VT_ZERO_POINT = `10`,
4150	VT_DETAILS_TYPE = `12`,
4151	VT_DETAILS = `14`,
4152	VT_QUANTIZED_DIMENSION = `16`
4153	};
4154	const flatbuffers::Vector<float> min() const* {
4155	return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
4156	}
4157	const flatbuffers::Vector<float> max() const* {
4158	return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
4159	}
4160	const flatbuffers::Vector<float> scale() const* {
4161	return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
4162	}
4163	const flatbuffers::Vector<int64_t> zero_point() const* {
4164	return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
4165	}
4166	tflite::QuantizationDetails details_type() const {
4167	return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, `0`));
4168	}
4169	const void details() const* {
4170	return GetPointer<const void *>(VT_DETAILS);
4171	}
4172	template<typename T> const T details_as() const*;
4173	const tflite::CustomQuantization details_as_CustomQuantization() const* {
4174	return details_type() == tflite::QuantizationDetails_CustomQuantization ? static_cast<const tflite::CustomQuantization >(details()) : nullptr*;
4175	}
4176	int32_t quantized_dimension() const {
4177	return GetField<int32_t>(VT_QUANTIZED_DIMENSION, `0`);
4178	}
4179	bool Verify(flatbuffers::Verifier &verifier) const {
4180	return VerifyTableStart(verifier) &&
4181	VerifyOffset(verifier, VT_MIN) &&
4182	verifier.VerifyVector(min()) &&
4183	VerifyOffset(verifier, VT_MAX) &&
4184	verifier.VerifyVector(max()) &&
4185	VerifyOffset(verifier, VT_SCALE) &&
4186	verifier.VerifyVector(scale()) &&
4187	VerifyOffset(verifier, VT_ZERO_POINT) &&
4188	verifier.VerifyVector(zero_point()) &&
4189	VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE, `1`) &&
4190	VerifyOffset(verifier, VT_DETAILS) &&
4191	VerifyQuantizationDetails(verifier, details(), details_type()) &&
4192	VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION, `4`) &&
4193	verifier.EndTable();
4194	}
4195	QuantizationParametersT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4196	void UnPackTo(QuantizationParametersT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4197	static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4198	};
4199
4200	template<> inline const tflite::CustomQuantization QuantizationParameters::details_as<tflite::CustomQuantization>() const* {
4201	return details_as_CustomQuantization();
4202	}
4203
4204	struct QuantizationParametersBuilder {
4205	typedef QuantizationParameters Table;
4206	flatbuffers::FlatBufferBuilder &fbb_;
4207	flatbuffers::uoffset_t start_;
4208	void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
4209	fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
4210	}
4211	void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
4212	fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
4213	}
4214	void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
4215	fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
4216	}
4217	void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) {
4218	fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
4219	}
4220	void add_details_type(tflite::QuantizationDetails details_type) {
4221	fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), `0`);
4222	}
4223	void add_details(flatbuffers::Offset<void> details) {
4224	fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
4225	}
4226	void add_quantized_dimension(int32_t quantized_dimension) {
4227	fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, `0`);
4228	}
4229	explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4230	: fbb_(_fbb) {
4231	start_ = fbb_.StartTable();
4232	}
4233	flatbuffers::Offset<QuantizationParameters> Finish() {
4234	const auto end = fbb_.EndTable(start_);
4235	auto o = flatbuffers::Offset<QuantizationParameters>(end);
4236	return o;
4237	}
4238	};
4239
4240	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
4241	flatbuffers::FlatBufferBuilder &_fbb,
4242	flatbuffers::Offset<flatbuffers::Vector<float>> min = `0`,
4243	flatbuffers::Offset<flatbuffers::Vector<float>> max = `0`,
4244	flatbuffers::Offset<flatbuffers::Vector<float>> scale = `0`,
4245	flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = `0`,
4246	tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
4247	flatbuffers::Offset<void> details = `0`,
4248	int32_t quantized_dimension = `0`) {
4249	QuantizationParametersBuilder builder_(_fbb);
4250	builder_.add_quantized_dimension(quantized_dimension);
4251	builder_.add_details(details);
4252	builder_.add_zero_point(zero_point);
4253	builder_.add_scale(scale);
4254	builder_.add_max(max);
4255	builder_.add_min(min);
4256	builder_.add_details_type(details_type);
4257	return builder_.Finish();
4258	}
4259
4260	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
4261	flatbuffers::FlatBufferBuilder &_fbb,
4262	const std::vector<float> min = nullptr*,
4263	const std::vector<float> max = nullptr*,
4264	const std::vector<float> scale = nullptr*,
4265	const std::vector<int64_t> zero_point = nullptr*,
4266	tflite::QuantizationDetails details_type = tflite::QuantizationDetails_NONE,
4267	flatbuffers::Offset<void> details = `0`,
4268	int32_t quantized_dimension = `0`) {
4269	auto min__ = min ? _fbb.CreateVector<float>(*min) : `0`;
4270	auto max__ = max ? _fbb.CreateVector<float>(*max) : `0`;
4271	auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : `0`;
4272	auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : `0`;
4273	return tflite::CreateQuantizationParameters(
4274	_fbb,
4275	min__,
4276	max__,
4277	scale__,
4278	zero_point__,
4279	details_type,
4280	details,
4281	quantized_dimension);
4282	}
4283
4284	flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4285
4286	struct Int32VectorT : public flatbuffers::NativeTable {
4287	typedef Int32Vector TableType;
4288	std::vector<int32_t> values{};
4289	};
4290
4291	struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4292	typedef Int32VectorT NativeTableType;
4293	typedef Int32VectorBuilder Builder;
4294	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4295	VT_VALUES = `4`
4296	};
4297	const flatbuffers::Vector<int32_t> values() const* {
4298	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
4299	}
4300	bool Verify(flatbuffers::Verifier &verifier) const {
4301	return VerifyTableStart(verifier) &&
4302	VerifyOffset(verifier, VT_VALUES) &&
4303	verifier.VerifyVector(values()) &&
4304	verifier.EndTable();
4305	}
4306	Int32VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4307	void UnPackTo(Int32VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4308	static flatbuffers::Offset<Int32Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4309	};
4310
4311	struct Int32VectorBuilder {
4312	typedef Int32Vector Table;
4313	flatbuffers::FlatBufferBuilder &fbb_;
4314	flatbuffers::uoffset_t start_;
4315	void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values) {
4316	fbb_.AddOffset(Int32Vector::VT_VALUES, values);
4317	}
4318	explicit Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4319	: fbb_(_fbb) {
4320	start_ = fbb_.StartTable();
4321	}
4322	flatbuffers::Offset<Int32Vector> Finish() {
4323	const auto end = fbb_.EndTable(start_);
4324	auto o = flatbuffers::Offset<Int32Vector>(end);
4325	return o;
4326	}
4327	};
4328
4329	inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(
4330	flatbuffers::FlatBufferBuilder &_fbb,
4331	flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = `0`) {
4332	Int32VectorBuilder builder_(_fbb);
4333	builder_.add_values(values);
4334	return builder_.Finish();
4335	}
4336
4337	inline flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
4338	flatbuffers::FlatBufferBuilder &_fbb,
4339	const std::vector<int32_t> values = nullptr*) {
4340	auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : `0`;
4341	return tflite::CreateInt32Vector(
4342	_fbb,
4343	values__);
4344	}
4345
4346	flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4347
4348	struct Uint16VectorT : public flatbuffers::NativeTable {
4349	typedef Uint16Vector TableType;
4350	std::vector<uint16_t> values{};
4351	};
4352
4353	struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4354	typedef Uint16VectorT NativeTableType;
4355	typedef Uint16VectorBuilder Builder;
4356	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4357	VT_VALUES = `4`
4358	};
4359	const flatbuffers::Vector<uint16_t> values() const* {
4360	return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
4361	}
4362	bool Verify(flatbuffers::Verifier &verifier) const {
4363	return VerifyTableStart(verifier) &&
4364	VerifyOffset(verifier, VT_VALUES) &&
4365	verifier.VerifyVector(values()) &&
4366	verifier.EndTable();
4367	}
4368	Uint16VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4369	void UnPackTo(Uint16VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4370	static flatbuffers::Offset<Uint16Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4371	};
4372
4373	struct Uint16VectorBuilder {
4374	typedef Uint16Vector Table;
4375	flatbuffers::FlatBufferBuilder &fbb_;
4376	flatbuffers::uoffset_t start_;
4377	void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values) {
4378	fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
4379	}
4380	explicit Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4381	: fbb_(_fbb) {
4382	start_ = fbb_.StartTable();
4383	}
4384	flatbuffers::Offset<Uint16Vector> Finish() {
4385	const auto end = fbb_.EndTable(start_);
4386	auto o = flatbuffers::Offset<Uint16Vector>(end);
4387	return o;
4388	}
4389	};
4390
4391	inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
4392	flatbuffers::FlatBufferBuilder &_fbb,
4393	flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = `0`) {
4394	Uint16VectorBuilder builder_(_fbb);
4395	builder_.add_values(values);
4396	return builder_.Finish();
4397	}
4398
4399	inline flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
4400	flatbuffers::FlatBufferBuilder &_fbb,
4401	const std::vector<uint16_t> values = nullptr*) {
4402	if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), `4`); }
4403	auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : `0`;
4404	return tflite::CreateUint16Vector(
4405	_fbb,
4406	values__);
4407	}
4408
4409	flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4410
4411	struct Uint8VectorT : public flatbuffers::NativeTable {
4412	typedef Uint8Vector TableType;
4413	std::vector<uint8_t> values{};
4414	};
4415
4416	struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4417	typedef Uint8VectorT NativeTableType;
4418	typedef Uint8VectorBuilder Builder;
4419	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4420	VT_VALUES = `4`
4421	};
4422	const flatbuffers::Vector<uint8_t> values() const* {
4423	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
4424	}
4425	bool Verify(flatbuffers::Verifier &verifier) const {
4426	return VerifyTableStart(verifier) &&
4427	VerifyOffset(verifier, VT_VALUES) &&
4428	verifier.VerifyVector(values()) &&
4429	verifier.EndTable();
4430	}
4431	Uint8VectorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4432	void UnPackTo(Uint8VectorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4433	static flatbuffers::Offset<Uint8Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4434	};
4435
4436	struct Uint8VectorBuilder {
4437	typedef Uint8Vector Table;
4438	flatbuffers::FlatBufferBuilder &fbb_;
4439	flatbuffers::uoffset_t start_;
4440	void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values) {
4441	fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
4442	}
4443	explicit Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4444	: fbb_(_fbb) {
4445	start_ = fbb_.StartTable();
4446	}
4447	flatbuffers::Offset<Uint8Vector> Finish() {
4448	const auto end = fbb_.EndTable(start_);
4449	auto o = flatbuffers::Offset<Uint8Vector>(end);
4450	return o;
4451	}
4452	};
4453
4454	inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
4455	flatbuffers::FlatBufferBuilder &_fbb,
4456	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = `0`) {
4457	Uint8VectorBuilder builder_(_fbb);
4458	builder_.add_values(values);
4459	return builder_.Finish();
4460	}
4461
4462	inline flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
4463	flatbuffers::FlatBufferBuilder &_fbb,
4464	const std::vector<uint8_t> values = nullptr*) {
4465	if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), `4`); }
4466	auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : `0`;
4467	return tflite::CreateUint8Vector(
4468	_fbb,
4469	values__);
4470	}
4471
4472	flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4473
4474	struct DimensionMetadataT : public flatbuffers::NativeTable {
4475	typedef DimensionMetadata TableType;
4476	tflite::DimensionType format = tflite::DimensionType_DENSE;
4477	int32_t dense_size = `0`;
4478	tflite::SparseIndexVectorUnion array_segments{};
4479	tflite::SparseIndexVectorUnion array_indices{};
4480	};
4481
4482	struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4483	typedef DimensionMetadataT NativeTableType;
4484	typedef DimensionMetadataBuilder Builder;
4485	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4486	VT_FORMAT = `4`,
4487	VT_DENSE_SIZE = `6`,
4488	VT_ARRAY_SEGMENTS_TYPE = `8`,
4489	VT_ARRAY_SEGMENTS = `10`,
4490	VT_ARRAY_INDICES_TYPE = `12`,
4491	VT_ARRAY_INDICES = `14`
4492	};
4493	tflite::DimensionType format() const {
4494	return static_cast<tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, `0`));
4495	}
4496	int32_t dense_size() const {
4497	return GetField<int32_t>(VT_DENSE_SIZE, `0`);
4498	}
4499	tflite::SparseIndexVector array_segments_type() const {
4500	return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, `0`));
4501	}
4502	const void array_segments() const* {
4503	return GetPointer<const void *>(VT_ARRAY_SEGMENTS);
4504	}
4505	template<typename T> const T array_segments_as() const*;
4506	const tflite::Int32Vector array_segments_as_Int32Vector() const* {
4507	return array_segments_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector >(array_segments()) : nullptr*;
4508	}
4509	const tflite::Uint16Vector array_segments_as_Uint16Vector() const* {
4510	return array_segments_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector >(array_segments()) : nullptr*;
4511	}
4512	const tflite::Uint8Vector array_segments_as_Uint8Vector() const* {
4513	return array_segments_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector >(array_segments()) : nullptr*;
4514	}
4515	tflite::SparseIndexVector array_indices_type() const {
4516	return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, `0`));
4517	}
4518	const void array_indices() const* {
4519	return GetPointer<const void *>(VT_ARRAY_INDICES);
4520	}
4521	template<typename T> const T array_indices_as() const*;
4522	const tflite::Int32Vector array_indices_as_Int32Vector() const* {
4523	return array_indices_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector >(array_indices()) : nullptr*;
4524	}
4525	const tflite::Uint16Vector array_indices_as_Uint16Vector() const* {
4526	return array_indices_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector >(array_indices()) : nullptr*;
4527	}
4528	const tflite::Uint8Vector array_indices_as_Uint8Vector() const* {
4529	return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector >(array_indices()) : nullptr*;
4530	}
4531	bool Verify(flatbuffers::Verifier &verifier) const {
4532	return VerifyTableStart(verifier) &&
4533	VerifyField<int8_t>(verifier, VT_FORMAT, `1`) &&
4534	VerifyField<int32_t>(verifier, VT_DENSE_SIZE, `4`) &&
4535	VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE, `1`) &&
4536	VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
4537	VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
4538	VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE, `1`) &&
4539	VerifyOffset(verifier, VT_ARRAY_INDICES) &&
4540	VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
4541	verifier.EndTable();
4542	}
4543	DimensionMetadataT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4544	void UnPackTo(DimensionMetadataT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4545	static flatbuffers::Offset<DimensionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4546	};
4547
4548	template<> inline const tflite::Int32Vector DimensionMetadata::array_segments_as<tflite::Int32Vector>() const* {
4549	return array_segments_as_Int32Vector();
4550	}
4551
4552	template<> inline const tflite::Uint16Vector DimensionMetadata::array_segments_as<tflite::Uint16Vector>() const* {
4553	return array_segments_as_Uint16Vector();
4554	}
4555
4556	template<> inline const tflite::Uint8Vector DimensionMetadata::array_segments_as<tflite::Uint8Vector>() const* {
4557	return array_segments_as_Uint8Vector();
4558	}
4559
4560	template<> inline const tflite::Int32Vector DimensionMetadata::array_indices_as<tflite::Int32Vector>() const* {
4561	return array_indices_as_Int32Vector();
4562	}
4563
4564	template<> inline const tflite::Uint16Vector DimensionMetadata::array_indices_as<tflite::Uint16Vector>() const* {
4565	return array_indices_as_Uint16Vector();
4566	}
4567
4568	template<> inline const tflite::Uint8Vector DimensionMetadata::array_indices_as<tflite::Uint8Vector>() const* {
4569	return array_indices_as_Uint8Vector();
4570	}
4571
4572	struct DimensionMetadataBuilder {
4573	typedef DimensionMetadata Table;
4574	flatbuffers::FlatBufferBuilder &fbb_;
4575	flatbuffers::uoffset_t start_;
4576	void add_format(tflite::DimensionType format) {
4577	fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), `0`);
4578	}
4579	void add_dense_size(int32_t dense_size) {
4580	fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, `0`);
4581	}
4582	void add_array_segments_type(tflite::SparseIndexVector array_segments_type) {
4583	fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), `0`);
4584	}
4585	void add_array_segments(flatbuffers::Offset<void> array_segments) {
4586	fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
4587	}
4588	void add_array_indices_type(tflite::SparseIndexVector array_indices_type) {
4589	fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), `0`);
4590	}
4591	void add_array_indices(flatbuffers::Offset<void> array_indices) {
4592	fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
4593	}
4594	explicit DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4595	: fbb_(_fbb) {
4596	start_ = fbb_.StartTable();
4597	}
4598	flatbuffers::Offset<DimensionMetadata> Finish() {
4599	const auto end = fbb_.EndTable(start_);
4600	auto o = flatbuffers::Offset<DimensionMetadata>(end);
4601	return o;
4602	}
4603	};
4604
4605	inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
4606	flatbuffers::FlatBufferBuilder &_fbb,
4607	tflite::DimensionType format = tflite::DimensionType_DENSE,
4608	int32_t dense_size = `0`,
4609	tflite::SparseIndexVector array_segments_type = tflite::SparseIndexVector_NONE,
4610	flatbuffers::Offset<void> array_segments = `0`,
4611	tflite::SparseIndexVector array_indices_type = tflite::SparseIndexVector_NONE,
4612	flatbuffers::Offset<void> array_indices = `0`) {
4613	DimensionMetadataBuilder builder_(_fbb);
4614	builder_.add_array_indices(array_indices);
4615	builder_.add_array_segments(array_segments);
4616	builder_.add_dense_size(dense_size);
4617	builder_.add_array_indices_type(array_indices_type);
4618	builder_.add_array_segments_type(array_segments_type);
4619	builder_.add_format(format);
4620	return builder_.Finish();
4621	}
4622
4623	flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4624
4625	struct SparsityParametersT : public flatbuffers::NativeTable {
4626	typedef SparsityParameters TableType;
4627	std::vector<int32_t> traversal_order{};
4628	std::vector<int32_t> block_map{};
4629	std::vector<std::unique_ptr<tflite::DimensionMetadataT>> dim_metadata{};
4630	SparsityParametersT() = default;
4631	SparsityParametersT(const SparsityParametersT &o);
4632	SparsityParametersT(SparsityParametersT&&) FLATBUFFERS_NOEXCEPT = default;
4633	SparsityParametersT &operator=(SparsityParametersT o) FLATBUFFERS_NOEXCEPT;
4634	};
4635
4636	struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4637	typedef SparsityParametersT NativeTableType;
4638	typedef SparsityParametersBuilder Builder;
4639	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4640	VT_TRAVERSAL_ORDER = `4`,
4641	VT_BLOCK_MAP = `6`,
4642	VT_DIM_METADATA = `8`
4643	};
4644	const flatbuffers::Vector<int32_t> traversal_order() const* {
4645	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
4646	}
4647	const flatbuffers::Vector<int32_t> block_map() const* {
4648	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
4649	}
4650	const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> dim_metadata() const* {
4651	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
4652	}
4653	bool Verify(flatbuffers::Verifier &verifier) const {
4654	return VerifyTableStart(verifier) &&
4655	VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
4656	verifier.VerifyVector(traversal_order()) &&
4657	VerifyOffset(verifier, VT_BLOCK_MAP) &&
4658	verifier.VerifyVector(block_map()) &&
4659	VerifyOffset(verifier, VT_DIM_METADATA) &&
4660	verifier.VerifyVector(dim_metadata()) &&
4661	verifier.VerifyVectorOfTables(dim_metadata()) &&
4662	verifier.EndTable();
4663	}
4664	SparsityParametersT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4665	void UnPackTo(SparsityParametersT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4666	static flatbuffers::Offset<SparsityParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4667	};
4668
4669	struct SparsityParametersBuilder {
4670	typedef SparsityParameters Table;
4671	flatbuffers::FlatBufferBuilder &fbb_;
4672	flatbuffers::uoffset_t start_;
4673	void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order) {
4674	fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
4675	}
4676	void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
4677	fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
4678	}
4679	void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
4680	fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
4681	}
4682	explicit SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4683	: fbb_(_fbb) {
4684	start_ = fbb_.StartTable();
4685	}
4686	flatbuffers::Offset<SparsityParameters> Finish() {
4687	const auto end = fbb_.EndTable(start_);
4688	auto o = flatbuffers::Offset<SparsityParameters>(end);
4689	return o;
4690	}
4691	};
4692
4693	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
4694	flatbuffers::FlatBufferBuilder &_fbb,
4695	flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = `0`,
4696	flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = `0`,
4697	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = `0`) {
4698	SparsityParametersBuilder builder_(_fbb);
4699	builder_.add_dim_metadata(dim_metadata);
4700	builder_.add_block_map(block_map);
4701	builder_.add_traversal_order(traversal_order);
4702	return builder_.Finish();
4703	}
4704
4705	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
4706	flatbuffers::FlatBufferBuilder &_fbb,
4707	const std::vector<int32_t> traversal_order = nullptr*,
4708	const std::vector<int32_t> block_map = nullptr*,
4709	const std::vector<flatbuffers::Offset<tflite::DimensionMetadata>> dim_metadata = nullptr*) {
4710	auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : `0`;
4711	auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : `0`;
4712	auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : `0`;
4713	return tflite::CreateSparsityParameters(
4714	_fbb,
4715	traversal_order__,
4716	block_map__,
4717	dim_metadata__);
4718	}
4719
4720	flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4721
4722	struct VariantSubTypeT : public flatbuffers::NativeTable {
4723	typedef VariantSubType TableType;
4724	std::vector<int32_t> shape{};
4725	tflite::TensorType type = tflite::TensorType_FLOAT32;
4726	bool has_rank = false;
4727	};
4728
4729	struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4730	typedef VariantSubTypeT NativeTableType;
4731	typedef VariantSubTypeBuilder Builder;
4732	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4733	VT_SHAPE = `4`,
4734	VT_TYPE = `6`,
4735	VT_HAS_RANK = `8`
4736	};
4737	const flatbuffers::Vector<int32_t> shape() const* {
4738	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
4739	}
4740	tflite::TensorType type() const {
4741	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, `0`));
4742	}
4743	bool has_rank() const {
4744	return GetField<uint8_t>(VT_HAS_RANK, `0`) != `0`;
4745	}
4746	bool Verify(flatbuffers::Verifier &verifier) const {
4747	return VerifyTableStart(verifier) &&
4748	VerifyOffset(verifier, VT_SHAPE) &&
4749	verifier.VerifyVector(shape()) &&
4750	VerifyField<int8_t>(verifier, VT_TYPE, `1`) &&
4751	VerifyField<uint8_t>(verifier, VT_HAS_RANK, `1`) &&
4752	verifier.EndTable();
4753	}
4754	VariantSubTypeT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4755	void UnPackTo(VariantSubTypeT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4756	static flatbuffers::Offset<VariantSubType> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4757	};
4758
4759	struct VariantSubTypeBuilder {
4760	typedef VariantSubType Table;
4761	flatbuffers::FlatBufferBuilder &fbb_;
4762	flatbuffers::uoffset_t start_;
4763	void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
4764	fbb_.AddOffset(VariantSubType::VT_SHAPE, shape);
4765	}
4766	void add_type(tflite::TensorType type) {
4767	fbb_.AddElement<int8_t>(VariantSubType::VT_TYPE, static_cast<int8_t>(type), `0`);
4768	}
4769	void add_has_rank(bool has_rank) {
4770	fbb_.AddElement<uint8_t>(VariantSubType::VT_HAS_RANK, static_cast<uint8_t>(has_rank), `0`);
4771	}
4772	explicit VariantSubTypeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4773	: fbb_(_fbb) {
4774	start_ = fbb_.StartTable();
4775	}
4776	flatbuffers::Offset<VariantSubType> Finish() {
4777	const auto end = fbb_.EndTable(start_);
4778	auto o = flatbuffers::Offset<VariantSubType>(end);
4779	return o;
4780	}
4781	};
4782
4783	inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(
4784	flatbuffers::FlatBufferBuilder &_fbb,
4785	flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = `0`,
4786	tflite::TensorType type = tflite::TensorType_FLOAT32,
4787	bool has_rank = false) {
4788	VariantSubTypeBuilder builder_(_fbb);
4789	builder_.add_shape(shape);
4790	builder_.add_has_rank(has_rank);
4791	builder_.add_type(type);
4792	return builder_.Finish();
4793	}
4794
4795	inline flatbuffers::Offset<VariantSubType> CreateVariantSubTypeDirect(
4796	flatbuffers::FlatBufferBuilder &_fbb,
4797	const std::vector<int32_t> shape = nullptr*,
4798	tflite::TensorType type = tflite::TensorType_FLOAT32,
4799	bool has_rank = false) {
4800	auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : `0`;
4801	return tflite::CreateVariantSubType(
4802	_fbb,
4803	shape__,
4804	type,
4805	has_rank);
4806	}
4807
4808	flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
4809
4810	struct TensorT : public flatbuffers::NativeTable {
4811	typedef Tensor TableType;
4812	std::vector<int32_t> shape{};
4813	tflite::TensorType type = tflite::TensorType_FLOAT32;
4814	uint32_t buffer = `0`;
4815	std::string name{};
4816	std::unique_ptr<tflite::QuantizationParametersT> quantization{};
4817	bool is_variable = false;
4818	std::unique_ptr<tflite::SparsityParametersT> sparsity{};
4819	std::vector<int32_t> shape_signature{};
4820	bool has_rank = false;
4821	std::vector<std::unique_ptr<tflite::VariantSubTypeT>> variant_tensors{};
4822	TensorT() = default;
4823	TensorT(const TensorT &o);
4824	TensorT(TensorT&&) FLATBUFFERS_NOEXCEPT = default;
4825	TensorT &operator=(TensorT o) FLATBUFFERS_NOEXCEPT;
4826	};
4827
4828	struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4829	typedef TensorT NativeTableType;
4830	typedef TensorBuilder Builder;
4831	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4832	VT_SHAPE = `4`,
4833	VT_TYPE = `6`,
4834	VT_BUFFER = `8`,
4835	VT_NAME = `10`,
4836	VT_QUANTIZATION = `12`,
4837	VT_IS_VARIABLE = `14`,
4838	VT_SPARSITY = `16`,
4839	VT_SHAPE_SIGNATURE = `18`,
4840	VT_HAS_RANK = `20`,
4841	VT_VARIANT_TENSORS = `22`
4842	};
4843	const flatbuffers::Vector<int32_t> shape() const* {
4844	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
4845	}
4846	tflite::TensorType type() const {
4847	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, `0`));
4848	}
4849	uint32_t buffer() const {
4850	return GetField<uint32_t>(VT_BUFFER, `0`);
4851	}
4852	const flatbuffers::String name() const* {
4853	return GetPointer<const flatbuffers::String *>(VT_NAME);
4854	}
4855	const tflite::QuantizationParameters quantization() const* {
4856	return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
4857	}
4858	bool is_variable() const {
4859	return GetField<uint8_t>(VT_IS_VARIABLE, `0`) != `0`;
4860	}
4861	const tflite::SparsityParameters sparsity() const* {
4862	return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
4863	}
4864	const flatbuffers::Vector<int32_t> shape_signature() const* {
4865	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
4866	}
4867	bool has_rank() const {
4868	return GetField<uint8_t>(VT_HAS_RANK, `0`) != `0`;
4869	}
4870	const flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>> variant_tensors() const* {
4871	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>> *>(VT_VARIANT_TENSORS);
4872	}
4873	bool Verify(flatbuffers::Verifier &verifier) const {
4874	return VerifyTableStart(verifier) &&
4875	VerifyOffset(verifier, VT_SHAPE) &&
4876	verifier.VerifyVector(shape()) &&
4877	VerifyField<int8_t>(verifier, VT_TYPE, `1`) &&
4878	VerifyField<uint32_t>(verifier, VT_BUFFER, `4`) &&
4879	VerifyOffset(verifier, VT_NAME) &&
4880	verifier.VerifyString(name()) &&
4881	VerifyOffset(verifier, VT_QUANTIZATION) &&
4882	verifier.VerifyTable(quantization()) &&
4883	VerifyField<uint8_t>(verifier, VT_IS_VARIABLE, `1`) &&
4884	VerifyOffset(verifier, VT_SPARSITY) &&
4885	verifier.VerifyTable(sparsity()) &&
4886	VerifyOffset(verifier, VT_SHAPE_SIGNATURE) &&
4887	verifier.VerifyVector(shape_signature()) &&
4888	VerifyField<uint8_t>(verifier, VT_HAS_RANK, `1`) &&
4889	VerifyOffset(verifier, VT_VARIANT_TENSORS) &&
4890	verifier.VerifyVector(variant_tensors()) &&
4891	verifier.VerifyVectorOfTables(variant_tensors()) &&
4892	verifier.EndTable();
4893	}
4894	TensorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4895	void UnPackTo(TensorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
4896	static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
4897	};
4898
4899	struct TensorBuilder {
4900	typedef Tensor Table;
4901	flatbuffers::FlatBufferBuilder &fbb_;
4902	flatbuffers::uoffset_t start_;
4903	void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
4904	fbb_.AddOffset(Tensor::VT_SHAPE, shape);
4905	}
4906	void add_type(tflite::TensorType type) {
4907	fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), `0`);
4908	}
4909	void add_buffer(uint32_t buffer) {
4910	fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, `0`);
4911	}
4912	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
4913	fbb_.AddOffset(Tensor::VT_NAME, name);
4914	}
4915	void add_quantization(flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
4916	fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
4917	}
4918	void add_is_variable(bool is_variable) {
4919	fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), `0`);
4920	}
4921	void add_sparsity(flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
4922	fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
4923	}
4924	void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature) {
4925	fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
4926	}
4927	void add_has_rank(bool has_rank) {
4928	fbb_.AddElement<uint8_t>(Tensor::VT_HAS_RANK, static_cast<uint8_t>(has_rank), `0`);
4929	}
4930	void add_variant_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors) {
4931	fbb_.AddOffset(Tensor::VT_VARIANT_TENSORS, variant_tensors);
4932	}
4933	explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4934	: fbb_(_fbb) {
4935	start_ = fbb_.StartTable();
4936	}
4937	flatbuffers::Offset<Tensor> Finish() {
4938	const auto end = fbb_.EndTable(start_);
4939	auto o = flatbuffers::Offset<Tensor>(end);
4940	return o;
4941	}
4942	};
4943
4944	inline flatbuffers::Offset<Tensor> CreateTensor(
4945	flatbuffers::FlatBufferBuilder &_fbb,
4946	flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = `0`,
4947	tflite::TensorType type = tflite::TensorType_FLOAT32,
4948	uint32_t buffer = `0`,
4949	flatbuffers::Offset<flatbuffers::String> name = `0`,
4950	flatbuffers::Offset<tflite::QuantizationParameters> quantization = `0`,
4951	bool is_variable = false,
4952	flatbuffers::Offset<tflite::SparsityParameters> sparsity = `0`,
4953	flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = `0`,
4954	bool has_rank = false,
4955	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors = `0`) {
4956	TensorBuilder builder_(_fbb);
4957	builder_.add_variant_tensors(variant_tensors);
4958	builder_.add_shape_signature(shape_signature);
4959	builder_.add_sparsity(sparsity);
4960	builder_.add_quantization(quantization);
4961	builder_.add_name(name);
4962	builder_.add_buffer(buffer);
4963	builder_.add_shape(shape);
4964	builder_.add_has_rank(has_rank);
4965	builder_.add_is_variable(is_variable);
4966	builder_.add_type(type);
4967	return builder_.Finish();
4968	}
4969
4970	inline flatbuffers::Offset<Tensor> CreateTensorDirect(
4971	flatbuffers::FlatBufferBuilder &_fbb,
4972	const std::vector<int32_t> shape = nullptr*,
4973	tflite::TensorType type = tflite::TensorType_FLOAT32,
4974	uint32_t buffer = `0`,
4975	const char name = nullptr*,
4976	flatbuffers::Offset<tflite::QuantizationParameters> quantization = `0`,
4977	bool is_variable = false,
4978	flatbuffers::Offset<tflite::SparsityParameters> sparsity = `0`,
4979	const std::vector<int32_t> shape_signature = nullptr*,
4980	bool has_rank = false,
4981	const std::vector<flatbuffers::Offset<tflite::VariantSubType>> variant_tensors = nullptr*) {
4982	auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : `0`;
4983	auto name__ = name ? _fbb.CreateString(name) : `0`;
4984	auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : `0`;
4985	auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::VariantSubType>>(*variant_tensors) : `0`;
4986	return tflite::CreateTensor(
4987	_fbb,
4988	shape__,
4989	type,
4990	buffer,
4991	name__,
4992	quantization,
4993	is_variable,
4994	sparsity,
4995	shape_signature__,
4996	has_rank,
4997	variant_tensors__);
4998	}
4999
5000	flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5001
5002	struct Conv2DOptionsT : public flatbuffers::NativeTable {
5003	typedef Conv2DOptions TableType;
5004	tflite::Padding padding = tflite::Padding_SAME;
5005	int32_t stride_w = `0`;
5006	int32_t stride_h = `0`;
5007	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5008	int32_t dilation_w_factor = `1`;
5009	int32_t dilation_h_factor = `1`;
5010	};
5011
5012	struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5013	typedef Conv2DOptionsT NativeTableType;
5014	typedef Conv2DOptionsBuilder Builder;
5015	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5016	VT_PADDING = `4`,
5017	VT_STRIDE_W = `6`,
5018	VT_STRIDE_H = `8`,
5019	VT_FUSED_ACTIVATION_FUNCTION = `10`,
5020	VT_DILATION_W_FACTOR = `12`,
5021	VT_DILATION_H_FACTOR = `14`
5022	};
5023	tflite::Padding padding() const {
5024	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
5025	}
5026	int32_t stride_w() const {
5027	return GetField<int32_t>(VT_STRIDE_W, `0`);
5028	}
5029	int32_t stride_h() const {
5030	return GetField<int32_t>(VT_STRIDE_H, `0`);
5031	}
5032	tflite::ActivationFunctionType fused_activation_function() const {
5033	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5034	}
5035	int32_t dilation_w_factor() const {
5036	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
5037	}
5038	int32_t dilation_h_factor() const {
5039	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
5040	}
5041	bool Verify(flatbuffers::Verifier &verifier) const {
5042	return VerifyTableStart(verifier) &&
5043	VerifyField<int8_t>(verifier, VT_PADDING, `1`) &&
5044	VerifyField<int32_t>(verifier, VT_STRIDE_W, `4`) &&
5045	VerifyField<int32_t>(verifier, VT_STRIDE_H, `4`) &&
5046	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5047	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, `4`) &&
5048	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, `4`) &&
5049	verifier.EndTable();
5050	}
5051	Conv2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5052	void UnPackTo(Conv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5053	static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5054	};
5055
5056	struct Conv2DOptionsBuilder {
5057	typedef Conv2DOptions Table;
5058	flatbuffers::FlatBufferBuilder &fbb_;
5059	flatbuffers::uoffset_t start_;
5060	void add_padding(tflite::Padding padding) {
5061	fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
5062	}
5063	void add_stride_w(int32_t stride_w) {
5064	fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, `0`);
5065	}
5066	void add_stride_h(int32_t stride_h) {
5067	fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, `0`);
5068	}
5069	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5070	fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5071	}
5072	void add_dilation_w_factor(int32_t dilation_w_factor) {
5073	fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
5074	}
5075	void add_dilation_h_factor(int32_t dilation_h_factor) {
5076	fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
5077	}
5078	explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5079	: fbb_(_fbb) {
5080	start_ = fbb_.StartTable();
5081	}
5082	flatbuffers::Offset<Conv2DOptions> Finish() {
5083	const auto end = fbb_.EndTable(start_);
5084	auto o = flatbuffers::Offset<Conv2DOptions>(end);
5085	return o;
5086	}
5087	};
5088
5089	inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
5090	flatbuffers::FlatBufferBuilder &_fbb,
5091	tflite::Padding padding = tflite::Padding_SAME,
5092	int32_t stride_w = `0`,
5093	int32_t stride_h = `0`,
5094	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5095	int32_t dilation_w_factor = `1`,
5096	int32_t dilation_h_factor = `1`) {
5097	Conv2DOptionsBuilder builder_(_fbb);
5098	builder_.add_dilation_h_factor(dilation_h_factor);
5099	builder_.add_dilation_w_factor(dilation_w_factor);
5100	builder_.add_stride_h(stride_h);
5101	builder_.add_stride_w(stride_w);
5102	builder_.add_fused_activation_function(fused_activation_function);
5103	builder_.add_padding(padding);
5104	return builder_.Finish();
5105	}
5106
5107	flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5108
5109	struct Conv3DOptionsT : public flatbuffers::NativeTable {
5110	typedef Conv3DOptions TableType;
5111	tflite::Padding padding = tflite::Padding_SAME;
5112	int32_t stride_d = `0`;
5113	int32_t stride_w = `0`;
5114	int32_t stride_h = `0`;
5115	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5116	int32_t dilation_d_factor = `1`;
5117	int32_t dilation_w_factor = `1`;
5118	int32_t dilation_h_factor = `1`;
5119	};
5120
5121	struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5122	typedef Conv3DOptionsT NativeTableType;
5123	typedef Conv3DOptionsBuilder Builder;
5124	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5125	VT_PADDING = `4`,
5126	VT_STRIDE_D = `6`,
5127	VT_STRIDE_W = `8`,
5128	VT_STRIDE_H = `10`,
5129	VT_FUSED_ACTIVATION_FUNCTION = `12`,
5130	VT_DILATION_D_FACTOR = `14`,
5131	VT_DILATION_W_FACTOR = `16`,
5132	VT_DILATION_H_FACTOR = `18`
5133	};
5134	tflite::Padding padding() const {
5135	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
5136	}
5137	int32_t stride_d() const {
5138	return GetField<int32_t>(VT_STRIDE_D, `0`);
5139	}
5140	int32_t stride_w() const {
5141	return GetField<int32_t>(VT_STRIDE_W, `0`);
5142	}
5143	int32_t stride_h() const {
5144	return GetField<int32_t>(VT_STRIDE_H, `0`);
5145	}
5146	tflite::ActivationFunctionType fused_activation_function() const {
5147	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5148	}
5149	int32_t dilation_d_factor() const {
5150	return GetField<int32_t>(VT_DILATION_D_FACTOR, `1`);
5151	}
5152	int32_t dilation_w_factor() const {
5153	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
5154	}
5155	int32_t dilation_h_factor() const {
5156	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
5157	}
5158	bool Verify(flatbuffers::Verifier &verifier) const {
5159	return VerifyTableStart(verifier) &&
5160	VerifyField<int8_t>(verifier, VT_PADDING, `1`) &&
5161	VerifyField<int32_t>(verifier, VT_STRIDE_D, `4`) &&
5162	VerifyField<int32_t>(verifier, VT_STRIDE_W, `4`) &&
5163	VerifyField<int32_t>(verifier, VT_STRIDE_H, `4`) &&
5164	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5165	VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR, `4`) &&
5166	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, `4`) &&
5167	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, `4`) &&
5168	verifier.EndTable();
5169	}
5170	Conv3DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5171	void UnPackTo(Conv3DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5172	static flatbuffers::Offset<Conv3DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5173	};
5174
5175	struct Conv3DOptionsBuilder {
5176	typedef Conv3DOptions Table;
5177	flatbuffers::FlatBufferBuilder &fbb_;
5178	flatbuffers::uoffset_t start_;
5179	void add_padding(tflite::Padding padding) {
5180	fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
5181	}
5182	void add_stride_d(int32_t stride_d) {
5183	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, `0`);
5184	}
5185	void add_stride_w(int32_t stride_w) {
5186	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, `0`);
5187	}
5188	void add_stride_h(int32_t stride_h) {
5189	fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, `0`);
5190	}
5191	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5192	fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5193	}
5194	void add_dilation_d_factor(int32_t dilation_d_factor) {
5195	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, `1`);
5196	}
5197	void add_dilation_w_factor(int32_t dilation_w_factor) {
5198	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
5199	}
5200	void add_dilation_h_factor(int32_t dilation_h_factor) {
5201	fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
5202	}
5203	explicit Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5204	: fbb_(_fbb) {
5205	start_ = fbb_.StartTable();
5206	}
5207	flatbuffers::Offset<Conv3DOptions> Finish() {
5208	const auto end = fbb_.EndTable(start_);
5209	auto o = flatbuffers::Offset<Conv3DOptions>(end);
5210	return o;
5211	}
5212	};
5213
5214	inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
5215	flatbuffers::FlatBufferBuilder &_fbb,
5216	tflite::Padding padding = tflite::Padding_SAME,
5217	int32_t stride_d = `0`,
5218	int32_t stride_w = `0`,
5219	int32_t stride_h = `0`,
5220	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5221	int32_t dilation_d_factor = `1`,
5222	int32_t dilation_w_factor = `1`,
5223	int32_t dilation_h_factor = `1`) {
5224	Conv3DOptionsBuilder builder_(_fbb);
5225	builder_.add_dilation_h_factor(dilation_h_factor);
5226	builder_.add_dilation_w_factor(dilation_w_factor);
5227	builder_.add_dilation_d_factor(dilation_d_factor);
5228	builder_.add_stride_h(stride_h);
5229	builder_.add_stride_w(stride_w);
5230	builder_.add_stride_d(stride_d);
5231	builder_.add_fused_activation_function(fused_activation_function);
5232	builder_.add_padding(padding);
5233	return builder_.Finish();
5234	}
5235
5236	flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5237
5238	struct Pool2DOptionsT : public flatbuffers::NativeTable {
5239	typedef Pool2DOptions TableType;
5240	tflite::Padding padding = tflite::Padding_SAME;
5241	int32_t stride_w = `0`;
5242	int32_t stride_h = `0`;
5243	int32_t filter_width = `0`;
5244	int32_t filter_height = `0`;
5245	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5246	};
5247
5248	struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5249	typedef Pool2DOptionsT NativeTableType;
5250	typedef Pool2DOptionsBuilder Builder;
5251	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5252	VT_PADDING = `4`,
5253	VT_STRIDE_W = `6`,
5254	VT_STRIDE_H = `8`,
5255	VT_FILTER_WIDTH = `10`,
5256	VT_FILTER_HEIGHT = `12`,
5257	VT_FUSED_ACTIVATION_FUNCTION = `14`
5258	};
5259	tflite::Padding padding() const {
5260	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
5261	}
5262	int32_t stride_w() const {
5263	return GetField<int32_t>(VT_STRIDE_W, `0`);
5264	}
5265	int32_t stride_h() const {
5266	return GetField<int32_t>(VT_STRIDE_H, `0`);
5267	}
5268	int32_t filter_width() const {
5269	return GetField<int32_t>(VT_FILTER_WIDTH, `0`);
5270	}
5271	int32_t filter_height() const {
5272	return GetField<int32_t>(VT_FILTER_HEIGHT, `0`);
5273	}
5274	tflite::ActivationFunctionType fused_activation_function() const {
5275	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5276	}
5277	bool Verify(flatbuffers::Verifier &verifier) const {
5278	return VerifyTableStart(verifier) &&
5279	VerifyField<int8_t>(verifier, VT_PADDING, `1`) &&
5280	VerifyField<int32_t>(verifier, VT_STRIDE_W, `4`) &&
5281	VerifyField<int32_t>(verifier, VT_STRIDE_H, `4`) &&
5282	VerifyField<int32_t>(verifier, VT_FILTER_WIDTH, `4`) &&
5283	VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT, `4`) &&
5284	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5285	verifier.EndTable();
5286	}
5287	Pool2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5288	void UnPackTo(Pool2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5289	static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5290	};
5291
5292	struct Pool2DOptionsBuilder {
5293	typedef Pool2DOptions Table;
5294	flatbuffers::FlatBufferBuilder &fbb_;
5295	flatbuffers::uoffset_t start_;
5296	void add_padding(tflite::Padding padding) {
5297	fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
5298	}
5299	void add_stride_w(int32_t stride_w) {
5300	fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, `0`);
5301	}
5302	void add_stride_h(int32_t stride_h) {
5303	fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, `0`);
5304	}
5305	void add_filter_width(int32_t filter_width) {
5306	fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, `0`);
5307	}
5308	void add_filter_height(int32_t filter_height) {
5309	fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, `0`);
5310	}
5311	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5312	fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5313	}
5314	explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5315	: fbb_(_fbb) {
5316	start_ = fbb_.StartTable();
5317	}
5318	flatbuffers::Offset<Pool2DOptions> Finish() {
5319	const auto end = fbb_.EndTable(start_);
5320	auto o = flatbuffers::Offset<Pool2DOptions>(end);
5321	return o;
5322	}
5323	};
5324
5325	inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
5326	flatbuffers::FlatBufferBuilder &_fbb,
5327	tflite::Padding padding = tflite::Padding_SAME,
5328	int32_t stride_w = `0`,
5329	int32_t stride_h = `0`,
5330	int32_t filter_width = `0`,
5331	int32_t filter_height = `0`,
5332	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
5333	Pool2DOptionsBuilder builder_(_fbb);
5334	builder_.add_filter_height(filter_height);
5335	builder_.add_filter_width(filter_width);
5336	builder_.add_stride_h(stride_h);
5337	builder_.add_stride_w(stride_w);
5338	builder_.add_fused_activation_function(fused_activation_function);
5339	builder_.add_padding(padding);
5340	return builder_.Finish();
5341	}
5342
5343	flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5344
5345	struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
5346	typedef DepthwiseConv2DOptions TableType;
5347	tflite::Padding padding = tflite::Padding_SAME;
5348	int32_t stride_w = `0`;
5349	int32_t stride_h = `0`;
5350	int32_t depth_multiplier = `0`;
5351	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5352	int32_t dilation_w_factor = `1`;
5353	int32_t dilation_h_factor = `1`;
5354	};
5355
5356	struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5357	typedef DepthwiseConv2DOptionsT NativeTableType;
5358	typedef DepthwiseConv2DOptionsBuilder Builder;
5359	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5360	VT_PADDING = `4`,
5361	VT_STRIDE_W = `6`,
5362	VT_STRIDE_H = `8`,
5363	VT_DEPTH_MULTIPLIER = `10`,
5364	VT_FUSED_ACTIVATION_FUNCTION = `12`,
5365	VT_DILATION_W_FACTOR = `14`,
5366	VT_DILATION_H_FACTOR = `16`
5367	};
5368	tflite::Padding padding() const {
5369	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
5370	}
5371	int32_t stride_w() const {
5372	return GetField<int32_t>(VT_STRIDE_W, `0`);
5373	}
5374	int32_t stride_h() const {
5375	return GetField<int32_t>(VT_STRIDE_H, `0`);
5376	}
5377	int32_t depth_multiplier() const {
5378	return GetField<int32_t>(VT_DEPTH_MULTIPLIER, `0`);
5379	}
5380	tflite::ActivationFunctionType fused_activation_function() const {
5381	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5382	}
5383	int32_t dilation_w_factor() const {
5384	return GetField<int32_t>(VT_DILATION_W_FACTOR, `1`);
5385	}
5386	int32_t dilation_h_factor() const {
5387	return GetField<int32_t>(VT_DILATION_H_FACTOR, `1`);
5388	}
5389	bool Verify(flatbuffers::Verifier &verifier) const {
5390	return VerifyTableStart(verifier) &&
5391	VerifyField<int8_t>(verifier, VT_PADDING, `1`) &&
5392	VerifyField<int32_t>(verifier, VT_STRIDE_W, `4`) &&
5393	VerifyField<int32_t>(verifier, VT_STRIDE_H, `4`) &&
5394	VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER, `4`) &&
5395	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5396	VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, `4`) &&
5397	VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, `4`) &&
5398	verifier.EndTable();
5399	}
5400	DepthwiseConv2DOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5401	void UnPackTo(DepthwiseConv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5402	static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5403	};
5404
5405	struct DepthwiseConv2DOptionsBuilder {
5406	typedef DepthwiseConv2DOptions Table;
5407	flatbuffers::FlatBufferBuilder &fbb_;
5408	flatbuffers::uoffset_t start_;
5409	void add_padding(tflite::Padding padding) {
5410	fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
5411	}
5412	void add_stride_w(int32_t stride_w) {
5413	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, `0`);
5414	}
5415	void add_stride_h(int32_t stride_h) {
5416	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, `0`);
5417	}
5418	void add_depth_multiplier(int32_t depth_multiplier) {
5419	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, `0`);
5420	}
5421	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5422	fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5423	}
5424	void add_dilation_w_factor(int32_t dilation_w_factor) {
5425	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, `1`);
5426	}
5427	void add_dilation_h_factor(int32_t dilation_h_factor) {
5428	fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, `1`);
5429	}
5430	explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5431	: fbb_(_fbb) {
5432	start_ = fbb_.StartTable();
5433	}
5434	flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
5435	const auto end = fbb_.EndTable(start_);
5436	auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
5437	return o;
5438	}
5439	};
5440
5441	inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
5442	flatbuffers::FlatBufferBuilder &_fbb,
5443	tflite::Padding padding = tflite::Padding_SAME,
5444	int32_t stride_w = `0`,
5445	int32_t stride_h = `0`,
5446	int32_t depth_multiplier = `0`,
5447	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5448	int32_t dilation_w_factor = `1`,
5449	int32_t dilation_h_factor = `1`) {
5450	DepthwiseConv2DOptionsBuilder builder_(_fbb);
5451	builder_.add_dilation_h_factor(dilation_h_factor);
5452	builder_.add_dilation_w_factor(dilation_w_factor);
5453	builder_.add_depth_multiplier(depth_multiplier);
5454	builder_.add_stride_h(stride_h);
5455	builder_.add_stride_w(stride_w);
5456	builder_.add_fused_activation_function(fused_activation_function);
5457	builder_.add_padding(padding);
5458	return builder_.Finish();
5459	}
5460
5461	flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5462
5463	struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable {
5464	typedef ConcatEmbeddingsOptions TableType;
5465	int32_t num_channels = `0`;
5466	std::vector<int32_t> num_columns_per_channel{};
5467	std::vector<int32_t> embedding_dim_per_channel{};
5468	};
5469
5470	struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5471	typedef ConcatEmbeddingsOptionsT NativeTableType;
5472	typedef ConcatEmbeddingsOptionsBuilder Builder;
5473	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5474	VT_NUM_CHANNELS = `4`,
5475	VT_NUM_COLUMNS_PER_CHANNEL = `6`,
5476	VT_EMBEDDING_DIM_PER_CHANNEL = `8`
5477	};
5478	int32_t num_channels() const {
5479	return GetField<int32_t>(VT_NUM_CHANNELS, `0`);
5480	}
5481	const flatbuffers::Vector<int32_t> num_columns_per_channel() const* {
5482	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
5483	}
5484	const flatbuffers::Vector<int32_t> embedding_dim_per_channel() const* {
5485	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
5486	}
5487	bool Verify(flatbuffers::Verifier &verifier) const {
5488	return VerifyTableStart(verifier) &&
5489	VerifyField<int32_t>(verifier, VT_NUM_CHANNELS, `4`) &&
5490	VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
5491	verifier.VerifyVector(num_columns_per_channel()) &&
5492	VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
5493	verifier.VerifyVector(embedding_dim_per_channel()) &&
5494	verifier.EndTable();
5495	}
5496	ConcatEmbeddingsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5497	void UnPackTo(ConcatEmbeddingsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5498	static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5499	};
5500
5501	struct ConcatEmbeddingsOptionsBuilder {
5502	typedef ConcatEmbeddingsOptions Table;
5503	flatbuffers::FlatBufferBuilder &fbb_;
5504	flatbuffers::uoffset_t start_;
5505	void add_num_channels(int32_t num_channels) {
5506	fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, `0`);
5507	}
5508	void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
5509	fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
5510	}
5511	void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
5512	fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
5513	}
5514	explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5515	: fbb_(_fbb) {
5516	start_ = fbb_.StartTable();
5517	}
5518	flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
5519	const auto end = fbb_.EndTable(start_);
5520	auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
5521	return o;
5522	}
5523	};
5524
5525	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
5526	flatbuffers::FlatBufferBuilder &_fbb,
5527	int32_t num_channels = `0`,
5528	flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = `0`,
5529	flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = `0`) {
5530	ConcatEmbeddingsOptionsBuilder builder_(_fbb);
5531	builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
5532	builder_.add_num_columns_per_channel(num_columns_per_channel);
5533	builder_.add_num_channels(num_channels);
5534	return builder_.Finish();
5535	}
5536
5537	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
5538	flatbuffers::FlatBufferBuilder &_fbb,
5539	int32_t num_channels = `0`,
5540	const std::vector<int32_t> num_columns_per_channel = nullptr*,
5541	const std::vector<int32_t> embedding_dim_per_channel = nullptr*) {
5542	auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : `0`;
5543	auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : `0`;
5544	return tflite::CreateConcatEmbeddingsOptions(
5545	_fbb,
5546	num_channels,
5547	num_columns_per_channel__,
5548	embedding_dim_per_channel__);
5549	}
5550
5551	flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5552
5553	struct LSHProjectionOptionsT : public flatbuffers::NativeTable {
5554	typedef LSHProjectionOptions TableType;
5555	tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN;
5556	};
5557
5558	struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5559	typedef LSHProjectionOptionsT NativeTableType;
5560	typedef LSHProjectionOptionsBuilder Builder;
5561	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5562	VT_TYPE = `4`
5563	};
5564	tflite::LSHProjectionType type() const {
5565	return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, `0`));
5566	}
5567	bool Verify(flatbuffers::Verifier &verifier) const {
5568	return VerifyTableStart(verifier) &&
5569	VerifyField<int8_t>(verifier, VT_TYPE, `1`) &&
5570	verifier.EndTable();
5571	}
5572	LSHProjectionOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5573	void UnPackTo(LSHProjectionOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5574	static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5575	};
5576
5577	struct LSHProjectionOptionsBuilder {
5578	typedef LSHProjectionOptions Table;
5579	flatbuffers::FlatBufferBuilder &fbb_;
5580	flatbuffers::uoffset_t start_;
5581	void add_type(tflite::LSHProjectionType type) {
5582	fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), `0`);
5583	}
5584	explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5585	: fbb_(_fbb) {
5586	start_ = fbb_.StartTable();
5587	}
5588	flatbuffers::Offset<LSHProjectionOptions> Finish() {
5589	const auto end = fbb_.EndTable(start_);
5590	auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
5591	return o;
5592	}
5593	};
5594
5595	inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
5596	flatbuffers::FlatBufferBuilder &_fbb,
5597	tflite::LSHProjectionType type = tflite::LSHProjectionType_UNKNOWN) {
5598	LSHProjectionOptionsBuilder builder_(_fbb);
5599	builder_.add_type(type);
5600	return builder_.Finish();
5601	}
5602
5603	flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5604
5605	struct SVDFOptionsT : public flatbuffers::NativeTable {
5606	typedef SVDFOptions TableType;
5607	int32_t rank = `0`;
5608	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5609	bool asymmetric_quantize_inputs = false;
5610	};
5611
5612	struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5613	typedef SVDFOptionsT NativeTableType;
5614	typedef SVDFOptionsBuilder Builder;
5615	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5616	VT_RANK = `4`,
5617	VT_FUSED_ACTIVATION_FUNCTION = `6`,
5618	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
5619	};
5620	int32_t rank() const {
5621	return GetField<int32_t>(VT_RANK, `0`);
5622	}
5623	tflite::ActivationFunctionType fused_activation_function() const {
5624	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5625	}
5626	bool asymmetric_quantize_inputs() const {
5627	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5628	}
5629	bool Verify(flatbuffers::Verifier &verifier) const {
5630	return VerifyTableStart(verifier) &&
5631	VerifyField<int32_t>(verifier, VT_RANK, `4`) &&
5632	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5633	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
5634	verifier.EndTable();
5635	}
5636	SVDFOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5637	void UnPackTo(SVDFOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5638	static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5639	};
5640
5641	struct SVDFOptionsBuilder {
5642	typedef SVDFOptions Table;
5643	flatbuffers::FlatBufferBuilder &fbb_;
5644	flatbuffers::uoffset_t start_;
5645	void add_rank(int32_t rank) {
5646	fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, `0`);
5647	}
5648	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5649	fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5650	}
5651	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5652	fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5653	}
5654	explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5655	: fbb_(_fbb) {
5656	start_ = fbb_.StartTable();
5657	}
5658	flatbuffers::Offset<SVDFOptions> Finish() {
5659	const auto end = fbb_.EndTable(start_);
5660	auto o = flatbuffers::Offset<SVDFOptions>(end);
5661	return o;
5662	}
5663	};
5664
5665	inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
5666	flatbuffers::FlatBufferBuilder &_fbb,
5667	int32_t rank = `0`,
5668	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5669	bool asymmetric_quantize_inputs = false) {
5670	SVDFOptionsBuilder builder_(_fbb);
5671	builder_.add_rank(rank);
5672	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5673	builder_.add_fused_activation_function(fused_activation_function);
5674	return builder_.Finish();
5675	}
5676
5677	flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5678
5679	struct RNNOptionsT : public flatbuffers::NativeTable {
5680	typedef RNNOptions TableType;
5681	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5682	bool asymmetric_quantize_inputs = false;
5683	};
5684
5685	struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5686	typedef RNNOptionsT NativeTableType;
5687	typedef RNNOptionsBuilder Builder;
5688	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5689	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5690	VT_ASYMMETRIC_QUANTIZE_INPUTS = `6`
5691	};
5692	tflite::ActivationFunctionType fused_activation_function() const {
5693	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5694	}
5695	bool asymmetric_quantize_inputs() const {
5696	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5697	}
5698	bool Verify(flatbuffers::Verifier &verifier) const {
5699	return VerifyTableStart(verifier) &&
5700	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5701	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
5702	verifier.EndTable();
5703	}
5704	RNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5705	void UnPackTo(RNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5706	static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5707	};
5708
5709	struct RNNOptionsBuilder {
5710	typedef RNNOptions Table;
5711	flatbuffers::FlatBufferBuilder &fbb_;
5712	flatbuffers::uoffset_t start_;
5713	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5714	fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5715	}
5716	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5717	fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5718	}
5719	explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5720	: fbb_(_fbb) {
5721	start_ = fbb_.StartTable();
5722	}
5723	flatbuffers::Offset<RNNOptions> Finish() {
5724	const auto end = fbb_.EndTable(start_);
5725	auto o = flatbuffers::Offset<RNNOptions>(end);
5726	return o;
5727	}
5728	};
5729
5730	inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
5731	flatbuffers::FlatBufferBuilder &_fbb,
5732	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5733	bool asymmetric_quantize_inputs = false) {
5734	RNNOptionsBuilder builder_(_fbb);
5735	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5736	builder_.add_fused_activation_function(fused_activation_function);
5737	return builder_.Finish();
5738	}
5739
5740	flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5741
5742	struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
5743	typedef SequenceRNNOptions TableType;
5744	bool time_major = false;
5745	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5746	bool asymmetric_quantize_inputs = false;
5747	};
5748
5749	struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5750	typedef SequenceRNNOptionsT NativeTableType;
5751	typedef SequenceRNNOptionsBuilder Builder;
5752	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5753	VT_TIME_MAJOR = `4`,
5754	VT_FUSED_ACTIVATION_FUNCTION = `6`,
5755	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
5756	};
5757	bool time_major() const {
5758	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
5759	}
5760	tflite::ActivationFunctionType fused_activation_function() const {
5761	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5762	}
5763	bool asymmetric_quantize_inputs() const {
5764	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5765	}
5766	bool Verify(flatbuffers::Verifier &verifier) const {
5767	return VerifyTableStart(verifier) &&
5768	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, `1`) &&
5769	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5770	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
5771	verifier.EndTable();
5772	}
5773	SequenceRNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5774	void UnPackTo(SequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5775	static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5776	};
5777
5778	struct SequenceRNNOptionsBuilder {
5779	typedef SequenceRNNOptions Table;
5780	flatbuffers::FlatBufferBuilder &fbb_;
5781	flatbuffers::uoffset_t start_;
5782	void add_time_major(bool time_major) {
5783	fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
5784	}
5785	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5786	fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5787	}
5788	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5789	fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5790	}
5791	explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5792	: fbb_(_fbb) {
5793	start_ = fbb_.StartTable();
5794	}
5795	flatbuffers::Offset<SequenceRNNOptions> Finish() {
5796	const auto end = fbb_.EndTable(start_);
5797	auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
5798	return o;
5799	}
5800	};
5801
5802	inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
5803	flatbuffers::FlatBufferBuilder &_fbb,
5804	bool time_major = false,
5805	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5806	bool asymmetric_quantize_inputs = false) {
5807	SequenceRNNOptionsBuilder builder_(_fbb);
5808	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5809	builder_.add_fused_activation_function(fused_activation_function);
5810	builder_.add_time_major(time_major);
5811	return builder_.Finish();
5812	}
5813
5814	flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5815
5816	struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
5817	typedef BidirectionalSequenceRNNOptions TableType;
5818	bool time_major = false;
5819	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5820	bool merge_outputs = false;
5821	bool asymmetric_quantize_inputs = false;
5822	};
5823
5824	struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5825	typedef BidirectionalSequenceRNNOptionsT NativeTableType;
5826	typedef BidirectionalSequenceRNNOptionsBuilder Builder;
5827	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5828	VT_TIME_MAJOR = `4`,
5829	VT_FUSED_ACTIVATION_FUNCTION = `6`,
5830	VT_MERGE_OUTPUTS = `8`,
5831	VT_ASYMMETRIC_QUANTIZE_INPUTS = `10`
5832	};
5833	bool time_major() const {
5834	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
5835	}
5836	tflite::ActivationFunctionType fused_activation_function() const {
5837	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5838	}
5839	bool merge_outputs() const {
5840	return GetField<uint8_t>(VT_MERGE_OUTPUTS, `0`) != `0`;
5841	}
5842	bool asymmetric_quantize_inputs() const {
5843	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5844	}
5845	bool Verify(flatbuffers::Verifier &verifier) const {
5846	return VerifyTableStart(verifier) &&
5847	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, `1`) &&
5848	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5849	VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, `1`) &&
5850	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
5851	verifier.EndTable();
5852	}
5853	BidirectionalSequenceRNNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5854	void UnPackTo(BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5855	static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5856	};
5857
5858	struct BidirectionalSequenceRNNOptionsBuilder {
5859	typedef BidirectionalSequenceRNNOptions Table;
5860	flatbuffers::FlatBufferBuilder &fbb_;
5861	flatbuffers::uoffset_t start_;
5862	void add_time_major(bool time_major) {
5863	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
5864	}
5865	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5866	fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5867	}
5868	void add_merge_outputs(bool merge_outputs) {
5869	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), `0`);
5870	}
5871	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5872	fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5873	}
5874	explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5875	: fbb_(_fbb) {
5876	start_ = fbb_.StartTable();
5877	}
5878	flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
5879	const auto end = fbb_.EndTable(start_);
5880	auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
5881	return o;
5882	}
5883	};
5884
5885	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
5886	flatbuffers::FlatBufferBuilder &_fbb,
5887	bool time_major = false,
5888	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5889	bool merge_outputs = false,
5890	bool asymmetric_quantize_inputs = false) {
5891	BidirectionalSequenceRNNOptionsBuilder builder_(_fbb);
5892	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5893	builder_.add_merge_outputs(merge_outputs);
5894	builder_.add_fused_activation_function(fused_activation_function);
5895	builder_.add_time_major(time_major);
5896	return builder_.Finish();
5897	}
5898
5899	flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5900
5901	struct FullyConnectedOptionsT : public flatbuffers::NativeTable {
5902	typedef FullyConnectedOptions TableType;
5903	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
5904	tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT;
5905	bool keep_num_dims = false;
5906	bool asymmetric_quantize_inputs = false;
5907	};
5908
5909	struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5910	typedef FullyConnectedOptionsT NativeTableType;
5911	typedef FullyConnectedOptionsBuilder Builder;
5912	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5913	VT_FUSED_ACTIVATION_FUNCTION = `4`,
5914	VT_WEIGHTS_FORMAT = `6`,
5915	VT_KEEP_NUM_DIMS = `8`,
5916	VT_ASYMMETRIC_QUANTIZE_INPUTS = `10`
5917	};
5918	tflite::ActivationFunctionType fused_activation_function() const {
5919	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
5920	}
5921	tflite::FullyConnectedOptionsWeightsFormat weights_format() const {
5922	return static_cast<tflite::FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, `0`));
5923	}
5924	bool keep_num_dims() const {
5925	return GetField<uint8_t>(VT_KEEP_NUM_DIMS, `0`) != `0`;
5926	}
5927	bool asymmetric_quantize_inputs() const {
5928	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
5929	}
5930	bool Verify(flatbuffers::Verifier &verifier) const {
5931	return VerifyTableStart(verifier) &&
5932	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
5933	VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT, `1`) &&
5934	VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS, `1`) &&
5935	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
5936	verifier.EndTable();
5937	}
5938	FullyConnectedOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5939	void UnPackTo(FullyConnectedOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
5940	static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
5941	};
5942
5943	struct FullyConnectedOptionsBuilder {
5944	typedef FullyConnectedOptions Table;
5945	flatbuffers::FlatBufferBuilder &fbb_;
5946	flatbuffers::uoffset_t start_;
5947	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
5948	fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
5949	}
5950	void add_weights_format(tflite::FullyConnectedOptionsWeightsFormat weights_format) {
5951	fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), `0`);
5952	}
5953	void add_keep_num_dims(bool keep_num_dims) {
5954	fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), `0`);
5955	}
5956	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5957	fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
5958	}
5959	explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5960	: fbb_(_fbb) {
5961	start_ = fbb_.StartTable();
5962	}
5963	flatbuffers::Offset<FullyConnectedOptions> Finish() {
5964	const auto end = fbb_.EndTable(start_);
5965	auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
5966	return o;
5967	}
5968	};
5969
5970	inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
5971	flatbuffers::FlatBufferBuilder &_fbb,
5972	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
5973	tflite::FullyConnectedOptionsWeightsFormat weights_format = tflite::FullyConnectedOptionsWeightsFormat_DEFAULT,
5974	bool keep_num_dims = false,
5975	bool asymmetric_quantize_inputs = false) {
5976	FullyConnectedOptionsBuilder builder_(_fbb);
5977	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5978	builder_.add_keep_num_dims(keep_num_dims);
5979	builder_.add_weights_format(weights_format);
5980	builder_.add_fused_activation_function(fused_activation_function);
5981	return builder_.Finish();
5982	}
5983
5984	flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
5985
5986	struct SoftmaxOptionsT : public flatbuffers::NativeTable {
5987	typedef SoftmaxOptions TableType;
5988	float beta = `0.0f`;
5989	};
5990
5991	struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5992	typedef SoftmaxOptionsT NativeTableType;
5993	typedef SoftmaxOptionsBuilder Builder;
5994	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5995	VT_BETA = `4`
5996	};
5997	float beta() const {
5998	return GetField<float>(VT_BETA, `0.0f`);
5999	}
6000	bool Verify(flatbuffers::Verifier &verifier) const {
6001	return VerifyTableStart(verifier) &&
6002	VerifyField<float>(verifier, VT_BETA, `4`) &&
6003	verifier.EndTable();
6004	}
6005	SoftmaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6006	void UnPackTo(SoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6007	static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6008	};
6009
6010	struct SoftmaxOptionsBuilder {
6011	typedef SoftmaxOptions Table;
6012	flatbuffers::FlatBufferBuilder &fbb_;
6013	flatbuffers::uoffset_t start_;
6014	void add_beta(float beta) {
6015	fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, `0.0f`);
6016	}
6017	explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6018	: fbb_(_fbb) {
6019	start_ = fbb_.StartTable();
6020	}
6021	flatbuffers::Offset<SoftmaxOptions> Finish() {
6022	const auto end = fbb_.EndTable(start_);
6023	auto o = flatbuffers::Offset<SoftmaxOptions>(end);
6024	return o;
6025	}
6026	};
6027
6028	inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
6029	flatbuffers::FlatBufferBuilder &_fbb,
6030	float beta = `0.0f`) {
6031	SoftmaxOptionsBuilder builder_(_fbb);
6032	builder_.add_beta(beta);
6033	return builder_.Finish();
6034	}
6035
6036	flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6037
6038	struct ConcatenationOptionsT : public flatbuffers::NativeTable {
6039	typedef ConcatenationOptions TableType;
6040	int32_t axis = `0`;
6041	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6042	};
6043
6044	struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6045	typedef ConcatenationOptionsT NativeTableType;
6046	typedef ConcatenationOptionsBuilder Builder;
6047	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6048	VT_AXIS = `4`,
6049	VT_FUSED_ACTIVATION_FUNCTION = `6`
6050	};
6051	int32_t axis() const {
6052	return GetField<int32_t>(VT_AXIS, `0`);
6053	}
6054	tflite::ActivationFunctionType fused_activation_function() const {
6055	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6056	}
6057	bool Verify(flatbuffers::Verifier &verifier) const {
6058	return VerifyTableStart(verifier) &&
6059	VerifyField<int32_t>(verifier, VT_AXIS, `4`) &&
6060	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6061	verifier.EndTable();
6062	}
6063	ConcatenationOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6064	void UnPackTo(ConcatenationOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6065	static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6066	};
6067
6068	struct ConcatenationOptionsBuilder {
6069	typedef ConcatenationOptions Table;
6070	flatbuffers::FlatBufferBuilder &fbb_;
6071	flatbuffers::uoffset_t start_;
6072	void add_axis(int32_t axis) {
6073	fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, `0`);
6074	}
6075	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6076	fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6077	}
6078	explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6079	: fbb_(_fbb) {
6080	start_ = fbb_.StartTable();
6081	}
6082	flatbuffers::Offset<ConcatenationOptions> Finish() {
6083	const auto end = fbb_.EndTable(start_);
6084	auto o = flatbuffers::Offset<ConcatenationOptions>(end);
6085	return o;
6086	}
6087	};
6088
6089	inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
6090	flatbuffers::FlatBufferBuilder &_fbb,
6091	int32_t axis = `0`,
6092	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
6093	ConcatenationOptionsBuilder builder_(_fbb);
6094	builder_.add_axis(axis);
6095	builder_.add_fused_activation_function(fused_activation_function);
6096	return builder_.Finish();
6097	}
6098
6099	flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6100
6101	struct AddOptionsT : public flatbuffers::NativeTable {
6102	typedef AddOptions TableType;
6103	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6104	bool pot_scale_int16 = true;
6105	};
6106
6107	struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6108	typedef AddOptionsT NativeTableType;
6109	typedef AddOptionsBuilder Builder;
6110	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6111	VT_FUSED_ACTIVATION_FUNCTION = `4`,
6112	VT_POT_SCALE_INT16 = `6`
6113	};
6114	tflite::ActivationFunctionType fused_activation_function() const {
6115	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6116	}
6117	bool pot_scale_int16() const {
6118	return GetField<uint8_t>(VT_POT_SCALE_INT16, `1`) != `0`;
6119	}
6120	bool Verify(flatbuffers::Verifier &verifier) const {
6121	return VerifyTableStart(verifier) &&
6122	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6123	VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, `1`) &&
6124	verifier.EndTable();
6125	}
6126	AddOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6127	void UnPackTo(AddOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6128	static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6129	};
6130
6131	struct AddOptionsBuilder {
6132	typedef AddOptions Table;
6133	flatbuffers::FlatBufferBuilder &fbb_;
6134	flatbuffers::uoffset_t start_;
6135	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6136	fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6137	}
6138	void add_pot_scale_int16(bool pot_scale_int16) {
6139	fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), `1`);
6140	}
6141	explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6142	: fbb_(_fbb) {
6143	start_ = fbb_.StartTable();
6144	}
6145	flatbuffers::Offset<AddOptions> Finish() {
6146	const auto end = fbb_.EndTable(start_);
6147	auto o = flatbuffers::Offset<AddOptions>(end);
6148	return o;
6149	}
6150	};
6151
6152	inline flatbuffers::Offset<AddOptions> CreateAddOptions(
6153	flatbuffers::FlatBufferBuilder &_fbb,
6154	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6155	bool pot_scale_int16 = true) {
6156	AddOptionsBuilder builder_(_fbb);
6157	builder_.add_pot_scale_int16(pot_scale_int16);
6158	builder_.add_fused_activation_function(fused_activation_function);
6159	return builder_.Finish();
6160	}
6161
6162	flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6163
6164	struct MulOptionsT : public flatbuffers::NativeTable {
6165	typedef MulOptions TableType;
6166	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6167	};
6168
6169	struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6170	typedef MulOptionsT NativeTableType;
6171	typedef MulOptionsBuilder Builder;
6172	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6173	VT_FUSED_ACTIVATION_FUNCTION = `4`
6174	};
6175	tflite::ActivationFunctionType fused_activation_function() const {
6176	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6177	}
6178	bool Verify(flatbuffers::Verifier &verifier) const {
6179	return VerifyTableStart(verifier) &&
6180	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6181	verifier.EndTable();
6182	}
6183	MulOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6184	void UnPackTo(MulOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6185	static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6186	};
6187
6188	struct MulOptionsBuilder {
6189	typedef MulOptions Table;
6190	flatbuffers::FlatBufferBuilder &fbb_;
6191	flatbuffers::uoffset_t start_;
6192	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6193	fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6194	}
6195	explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6196	: fbb_(_fbb) {
6197	start_ = fbb_.StartTable();
6198	}
6199	flatbuffers::Offset<MulOptions> Finish() {
6200	const auto end = fbb_.EndTable(start_);
6201	auto o = flatbuffers::Offset<MulOptions>(end);
6202	return o;
6203	}
6204	};
6205
6206	inline flatbuffers::Offset<MulOptions> CreateMulOptions(
6207	flatbuffers::FlatBufferBuilder &_fbb,
6208	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
6209	MulOptionsBuilder builder_(_fbb);
6210	builder_.add_fused_activation_function(fused_activation_function);
6211	return builder_.Finish();
6212	}
6213
6214	flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6215
6216	struct L2NormOptionsT : public flatbuffers::NativeTable {
6217	typedef L2NormOptions TableType;
6218	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6219	};
6220
6221	struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6222	typedef L2NormOptionsT NativeTableType;
6223	typedef L2NormOptionsBuilder Builder;
6224	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6225	VT_FUSED_ACTIVATION_FUNCTION = `4`
6226	};
6227	tflite::ActivationFunctionType fused_activation_function() const {
6228	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6229	}
6230	bool Verify(flatbuffers::Verifier &verifier) const {
6231	return VerifyTableStart(verifier) &&
6232	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6233	verifier.EndTable();
6234	}
6235	L2NormOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6236	void UnPackTo(L2NormOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6237	static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6238	};
6239
6240	struct L2NormOptionsBuilder {
6241	typedef L2NormOptions Table;
6242	flatbuffers::FlatBufferBuilder &fbb_;
6243	flatbuffers::uoffset_t start_;
6244	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6245	fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6246	}
6247	explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6248	: fbb_(_fbb) {
6249	start_ = fbb_.StartTable();
6250	}
6251	flatbuffers::Offset<L2NormOptions> Finish() {
6252	const auto end = fbb_.EndTable(start_);
6253	auto o = flatbuffers::Offset<L2NormOptions>(end);
6254	return o;
6255	}
6256	};
6257
6258	inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
6259	flatbuffers::FlatBufferBuilder &_fbb,
6260	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
6261	L2NormOptionsBuilder builder_(_fbb);
6262	builder_.add_fused_activation_function(fused_activation_function);
6263	return builder_.Finish();
6264	}
6265
6266	flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6267
6268	struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
6269	typedef LocalResponseNormalizationOptions TableType;
6270	int32_t radius = `0`;
6271	float bias = `0.0f`;
6272	float alpha = `0.0f`;
6273	float beta = `0.0f`;
6274	};
6275
6276	struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6277	typedef LocalResponseNormalizationOptionsT NativeTableType;
6278	typedef LocalResponseNormalizationOptionsBuilder Builder;
6279	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6280	VT_RADIUS = `4`,
6281	VT_BIAS = `6`,
6282	VT_ALPHA = `8`,
6283	VT_BETA = `10`
6284	};
6285	int32_t radius() const {
6286	return GetField<int32_t>(VT_RADIUS, `0`);
6287	}
6288	float bias() const {
6289	return GetField<float>(VT_BIAS, `0.0f`);
6290	}
6291	float alpha() const {
6292	return GetField<float>(VT_ALPHA, `0.0f`);
6293	}
6294	float beta() const {
6295	return GetField<float>(VT_BETA, `0.0f`);
6296	}
6297	bool Verify(flatbuffers::Verifier &verifier) const {
6298	return VerifyTableStart(verifier) &&
6299	VerifyField<int32_t>(verifier, VT_RADIUS, `4`) &&
6300	VerifyField<float>(verifier, VT_BIAS, `4`) &&
6301	VerifyField<float>(verifier, VT_ALPHA, `4`) &&
6302	VerifyField<float>(verifier, VT_BETA, `4`) &&
6303	verifier.EndTable();
6304	}
6305	LocalResponseNormalizationOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6306	void UnPackTo(LocalResponseNormalizationOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6307	static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6308	};
6309
6310	struct LocalResponseNormalizationOptionsBuilder {
6311	typedef LocalResponseNormalizationOptions Table;
6312	flatbuffers::FlatBufferBuilder &fbb_;
6313	flatbuffers::uoffset_t start_;
6314	void add_radius(int32_t radius) {
6315	fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, `0`);
6316	}
6317	void add_bias(float bias) {
6318	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, `0.0f`);
6319	}
6320	void add_alpha(float alpha) {
6321	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, `0.0f`);
6322	}
6323	void add_beta(float beta) {
6324	fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, `0.0f`);
6325	}
6326	explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6327	: fbb_(_fbb) {
6328	start_ = fbb_.StartTable();
6329	}
6330	flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
6331	const auto end = fbb_.EndTable(start_);
6332	auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
6333	return o;
6334	}
6335	};
6336
6337	inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
6338	flatbuffers::FlatBufferBuilder &_fbb,
6339	int32_t radius = `0`,
6340	float bias = `0.0f`,
6341	float alpha = `0.0f`,
6342	float beta = `0.0f`) {
6343	LocalResponseNormalizationOptionsBuilder builder_(_fbb);
6344	builder_.add_beta(beta);
6345	builder_.add_alpha(alpha);
6346	builder_.add_bias(bias);
6347	builder_.add_radius(radius);
6348	return builder_.Finish();
6349	}
6350
6351	flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6352
6353	struct LSTMOptionsT : public flatbuffers::NativeTable {
6354	typedef LSTMOptions TableType;
6355	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6356	float cell_clip = `0.0f`;
6357	float proj_clip = `0.0f`;
6358	tflite::LSTMKernelType kernel_type = tflite::LSTMKernelType_FULL;
6359	bool asymmetric_quantize_inputs = false;
6360	};
6361
6362	struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6363	typedef LSTMOptionsT NativeTableType;
6364	typedef LSTMOptionsBuilder Builder;
6365	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6366	VT_FUSED_ACTIVATION_FUNCTION = `4`,
6367	VT_CELL_CLIP = `6`,
6368	VT_PROJ_CLIP = `8`,
6369	VT_KERNEL_TYPE = `10`,
6370	VT_ASYMMETRIC_QUANTIZE_INPUTS = `12`
6371	};
6372	tflite::ActivationFunctionType fused_activation_function() const {
6373	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6374	}
6375	float cell_clip() const {
6376	return GetField<float>(VT_CELL_CLIP, `0.0f`);
6377	}
6378	float proj_clip() const {
6379	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
6380	}
6381	tflite::LSTMKernelType kernel_type() const {
6382	return static_cast<tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, `0`));
6383	}
6384	bool asymmetric_quantize_inputs() const {
6385	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
6386	}
6387	bool Verify(flatbuffers::Verifier &verifier) const {
6388	return VerifyTableStart(verifier) &&
6389	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6390	VerifyField<float>(verifier, VT_CELL_CLIP, `4`) &&
6391	VerifyField<float>(verifier, VT_PROJ_CLIP, `4`) &&
6392	VerifyField<int8_t>(verifier, VT_KERNEL_TYPE, `1`) &&
6393	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
6394	verifier.EndTable();
6395	}
6396	LSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6397	void UnPackTo(LSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6398	static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6399	};
6400
6401	struct LSTMOptionsBuilder {
6402	typedef LSTMOptions Table;
6403	flatbuffers::FlatBufferBuilder &fbb_;
6404	flatbuffers::uoffset_t start_;
6405	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6406	fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6407	}
6408	void add_cell_clip(float cell_clip) {
6409	fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
6410	}
6411	void add_proj_clip(float proj_clip) {
6412	fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
6413	}
6414	void add_kernel_type(tflite::LSTMKernelType kernel_type) {
6415	fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), `0`);
6416	}
6417	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6418	fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
6419	}
6420	explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6421	: fbb_(_fbb) {
6422	start_ = fbb_.StartTable();
6423	}
6424	flatbuffers::Offset<LSTMOptions> Finish() {
6425	const auto end = fbb_.EndTable(start_);
6426	auto o = flatbuffers::Offset<LSTMOptions>(end);
6427	return o;
6428	}
6429	};
6430
6431	inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
6432	flatbuffers::FlatBufferBuilder &_fbb,
6433	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6434	float cell_clip = `0.0f`,
6435	float proj_clip = `0.0f`,
6436	tflite::LSTMKernelType kernel_type = tflite::LSTMKernelType_FULL,
6437	bool asymmetric_quantize_inputs = false) {
6438	LSTMOptionsBuilder builder_(_fbb);
6439	builder_.add_proj_clip(proj_clip);
6440	builder_.add_cell_clip(cell_clip);
6441	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6442	builder_.add_kernel_type(kernel_type);
6443	builder_.add_fused_activation_function(fused_activation_function);
6444	return builder_.Finish();
6445	}
6446
6447	flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6448
6449	struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
6450	typedef UnidirectionalSequenceLSTMOptions TableType;
6451	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6452	float cell_clip = `0.0f`;
6453	float proj_clip = `0.0f`;
6454	bool time_major = false;
6455	bool asymmetric_quantize_inputs = false;
6456	};
6457
6458	struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6459	typedef UnidirectionalSequenceLSTMOptionsT NativeTableType;
6460	typedef UnidirectionalSequenceLSTMOptionsBuilder Builder;
6461	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6462	VT_FUSED_ACTIVATION_FUNCTION = `4`,
6463	VT_CELL_CLIP = `6`,
6464	VT_PROJ_CLIP = `8`,
6465	VT_TIME_MAJOR = `10`,
6466	VT_ASYMMETRIC_QUANTIZE_INPUTS = `12`
6467	};
6468	tflite::ActivationFunctionType fused_activation_function() const {
6469	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6470	}
6471	float cell_clip() const {
6472	return GetField<float>(VT_CELL_CLIP, `0.0f`);
6473	}
6474	float proj_clip() const {
6475	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
6476	}
6477	bool time_major() const {
6478	return GetField<uint8_t>(VT_TIME_MAJOR, `0`) != `0`;
6479	}
6480	bool asymmetric_quantize_inputs() const {
6481	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
6482	}
6483	bool Verify(flatbuffers::Verifier &verifier) const {
6484	return VerifyTableStart(verifier) &&
6485	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6486	VerifyField<float>(verifier, VT_CELL_CLIP, `4`) &&
6487	VerifyField<float>(verifier, VT_PROJ_CLIP, `4`) &&
6488	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, `1`) &&
6489	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
6490	verifier.EndTable();
6491	}
6492	UnidirectionalSequenceLSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6493	void UnPackTo(UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6494	static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6495	};
6496
6497	struct UnidirectionalSequenceLSTMOptionsBuilder {
6498	typedef UnidirectionalSequenceLSTMOptions Table;
6499	flatbuffers::FlatBufferBuilder &fbb_;
6500	flatbuffers::uoffset_t start_;
6501	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6502	fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6503	}
6504	void add_cell_clip(float cell_clip) {
6505	fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
6506	}
6507	void add_proj_clip(float proj_clip) {
6508	fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
6509	}
6510	void add_time_major(bool time_major) {
6511	fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `0`);
6512	}
6513	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6514	fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
6515	}
6516	explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6517	: fbb_(_fbb) {
6518	start_ = fbb_.StartTable();
6519	}
6520	flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
6521	const auto end = fbb_.EndTable(start_);
6522	auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
6523	return o;
6524	}
6525	};
6526
6527	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
6528	flatbuffers::FlatBufferBuilder &_fbb,
6529	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6530	float cell_clip = `0.0f`,
6531	float proj_clip = `0.0f`,
6532	bool time_major = false,
6533	bool asymmetric_quantize_inputs = false) {
6534	UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
6535	builder_.add_proj_clip(proj_clip);
6536	builder_.add_cell_clip(cell_clip);
6537	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6538	builder_.add_time_major(time_major);
6539	builder_.add_fused_activation_function(fused_activation_function);
6540	return builder_.Finish();
6541	}
6542
6543	flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6544
6545	struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
6546	typedef BidirectionalSequenceLSTMOptions TableType;
6547	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
6548	float cell_clip = `0.0f`;
6549	float proj_clip = `0.0f`;
6550	bool merge_outputs = false;
6551	bool time_major = true;
6552	bool asymmetric_quantize_inputs = false;
6553	};
6554
6555	struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6556	typedef BidirectionalSequenceLSTMOptionsT NativeTableType;
6557	typedef BidirectionalSequenceLSTMOptionsBuilder Builder;
6558	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6559	VT_FUSED_ACTIVATION_FUNCTION = `4`,
6560	VT_CELL_CLIP = `6`,
6561	VT_PROJ_CLIP = `8`,
6562	VT_MERGE_OUTPUTS = `10`,
6563	VT_TIME_MAJOR = `12`,
6564	VT_ASYMMETRIC_QUANTIZE_INPUTS = `14`
6565	};
6566	tflite::ActivationFunctionType fused_activation_function() const {
6567	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
6568	}
6569	float cell_clip() const {
6570	return GetField<float>(VT_CELL_CLIP, `0.0f`);
6571	}
6572	float proj_clip() const {
6573	return GetField<float>(VT_PROJ_CLIP, `0.0f`);
6574	}
6575	bool merge_outputs() const {
6576	return GetField<uint8_t>(VT_MERGE_OUTPUTS, `0`) != `0`;
6577	}
6578	bool time_major() const {
6579	return GetField<uint8_t>(VT_TIME_MAJOR, `1`) != `0`;
6580	}
6581	bool asymmetric_quantize_inputs() const {
6582	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
6583	}
6584	bool Verify(flatbuffers::Verifier &verifier) const {
6585	return VerifyTableStart(verifier) &&
6586	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
6587	VerifyField<float>(verifier, VT_CELL_CLIP, `4`) &&
6588	VerifyField<float>(verifier, VT_PROJ_CLIP, `4`) &&
6589	VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, `1`) &&
6590	VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, `1`) &&
6591	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
6592	verifier.EndTable();
6593	}
6594	BidirectionalSequenceLSTMOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6595	void UnPackTo(BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6596	static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6597	};
6598
6599	struct BidirectionalSequenceLSTMOptionsBuilder {
6600	typedef BidirectionalSequenceLSTMOptions Table;
6601	flatbuffers::FlatBufferBuilder &fbb_;
6602	flatbuffers::uoffset_t start_;
6603	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
6604	fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
6605	}
6606	void add_cell_clip(float cell_clip) {
6607	fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, `0.0f`);
6608	}
6609	void add_proj_clip(float proj_clip) {
6610	fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, `0.0f`);
6611	}
6612	void add_merge_outputs(bool merge_outputs) {
6613	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), `0`);
6614	}
6615	void add_time_major(bool time_major) {
6616	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), `1`);
6617	}
6618	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6619	fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
6620	}
6621	explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6622	: fbb_(_fbb) {
6623	start_ = fbb_.StartTable();
6624	}
6625	flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
6626	const auto end = fbb_.EndTable(start_);
6627	auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
6628	return o;
6629	}
6630	};
6631
6632	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
6633	flatbuffers::FlatBufferBuilder &_fbb,
6634	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
6635	float cell_clip = `0.0f`,
6636	float proj_clip = `0.0f`,
6637	bool merge_outputs = false,
6638	bool time_major = true,
6639	bool asymmetric_quantize_inputs = false) {
6640	BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb);
6641	builder_.add_proj_clip(proj_clip);
6642	builder_.add_cell_clip(cell_clip);
6643	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6644	builder_.add_time_major(time_major);
6645	builder_.add_merge_outputs(merge_outputs);
6646	builder_.add_fused_activation_function(fused_activation_function);
6647	return builder_.Finish();
6648	}
6649
6650	flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6651
6652	struct ResizeBilinearOptionsT : public flatbuffers::NativeTable {
6653	typedef ResizeBilinearOptions TableType;
6654	bool align_corners = false;
6655	bool half_pixel_centers = false;
6656	};
6657
6658	struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6659	typedef ResizeBilinearOptionsT NativeTableType;
6660	typedef ResizeBilinearOptionsBuilder Builder;
6661	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6662	VT_ALIGN_CORNERS = `8`,
6663	VT_HALF_PIXEL_CENTERS = `10`
6664	};
6665	bool align_corners() const {
6666	return GetField<uint8_t>(VT_ALIGN_CORNERS, `0`) != `0`;
6667	}
6668	bool half_pixel_centers() const {
6669	return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, `0`) != `0`;
6670	}
6671	bool Verify(flatbuffers::Verifier &verifier) const {
6672	return VerifyTableStart(verifier) &&
6673	VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, `1`) &&
6674	VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, `1`) &&
6675	verifier.EndTable();
6676	}
6677	ResizeBilinearOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6678	void UnPackTo(ResizeBilinearOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6679	static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6680	};
6681
6682	struct ResizeBilinearOptionsBuilder {
6683	typedef ResizeBilinearOptions Table;
6684	flatbuffers::FlatBufferBuilder &fbb_;
6685	flatbuffers::uoffset_t start_;
6686	void add_align_corners(bool align_corners) {
6687	fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), `0`);
6688	}
6689	void add_half_pixel_centers(bool half_pixel_centers) {
6690	fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), `0`);
6691	}
6692	explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6693	: fbb_(_fbb) {
6694	start_ = fbb_.StartTable();
6695	}
6696	flatbuffers::Offset<ResizeBilinearOptions> Finish() {
6697	const auto end = fbb_.EndTable(start_);
6698	auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
6699	return o;
6700	}
6701	};
6702
6703	inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
6704	flatbuffers::FlatBufferBuilder &_fbb,
6705	bool align_corners = false,
6706	bool half_pixel_centers = false) {
6707	ResizeBilinearOptionsBuilder builder_(_fbb);
6708	builder_.add_half_pixel_centers(half_pixel_centers);
6709	builder_.add_align_corners(align_corners);
6710	return builder_.Finish();
6711	}
6712
6713	flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6714
6715	struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable {
6716	typedef ResizeNearestNeighborOptions TableType;
6717	bool align_corners = false;
6718	bool half_pixel_centers = false;
6719	};
6720
6721	struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6722	typedef ResizeNearestNeighborOptionsT NativeTableType;
6723	typedef ResizeNearestNeighborOptionsBuilder Builder;
6724	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6725	VT_ALIGN_CORNERS = `4`,
6726	VT_HALF_PIXEL_CENTERS = `6`
6727	};
6728	bool align_corners() const {
6729	return GetField<uint8_t>(VT_ALIGN_CORNERS, `0`) != `0`;
6730	}
6731	bool half_pixel_centers() const {
6732	return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, `0`) != `0`;
6733	}
6734	bool Verify(flatbuffers::Verifier &verifier) const {
6735	return VerifyTableStart(verifier) &&
6736	VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, `1`) &&
6737	VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, `1`) &&
6738	verifier.EndTable();
6739	}
6740	ResizeNearestNeighborOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6741	void UnPackTo(ResizeNearestNeighborOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6742	static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6743	};
6744
6745	struct ResizeNearestNeighborOptionsBuilder {
6746	typedef ResizeNearestNeighborOptions Table;
6747	flatbuffers::FlatBufferBuilder &fbb_;
6748	flatbuffers::uoffset_t start_;
6749	void add_align_corners(bool align_corners) {
6750	fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), `0`);
6751	}
6752	void add_half_pixel_centers(bool half_pixel_centers) {
6753	fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), `0`);
6754	}
6755	explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6756	: fbb_(_fbb) {
6757	start_ = fbb_.StartTable();
6758	}
6759	flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
6760	const auto end = fbb_.EndTable(start_);
6761	auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
6762	return o;
6763	}
6764	};
6765
6766	inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
6767	flatbuffers::FlatBufferBuilder &_fbb,
6768	bool align_corners = false,
6769	bool half_pixel_centers = false) {
6770	ResizeNearestNeighborOptionsBuilder builder_(_fbb);
6771	builder_.add_half_pixel_centers(half_pixel_centers);
6772	builder_.add_align_corners(align_corners);
6773	return builder_.Finish();
6774	}
6775
6776	flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6777
6778	struct CallOptionsT : public flatbuffers::NativeTable {
6779	typedef CallOptions TableType;
6780	uint32_t subgraph = `0`;
6781	};
6782
6783	struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6784	typedef CallOptionsT NativeTableType;
6785	typedef CallOptionsBuilder Builder;
6786	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6787	VT_SUBGRAPH = `4`
6788	};
6789	uint32_t subgraph() const {
6790	return GetField<uint32_t>(VT_SUBGRAPH, `0`);
6791	}
6792	bool Verify(flatbuffers::Verifier &verifier) const {
6793	return VerifyTableStart(verifier) &&
6794	VerifyField<uint32_t>(verifier, VT_SUBGRAPH, `4`) &&
6795	verifier.EndTable();
6796	}
6797	CallOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6798	void UnPackTo(CallOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6799	static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6800	};
6801
6802	struct CallOptionsBuilder {
6803	typedef CallOptions Table;
6804	flatbuffers::FlatBufferBuilder &fbb_;
6805	flatbuffers::uoffset_t start_;
6806	void add_subgraph(uint32_t subgraph) {
6807	fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, `0`);
6808	}
6809	explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6810	: fbb_(_fbb) {
6811	start_ = fbb_.StartTable();
6812	}
6813	flatbuffers::Offset<CallOptions> Finish() {
6814	const auto end = fbb_.EndTable(start_);
6815	auto o = flatbuffers::Offset<CallOptions>(end);
6816	return o;
6817	}
6818	};
6819
6820	inline flatbuffers::Offset<CallOptions> CreateCallOptions(
6821	flatbuffers::FlatBufferBuilder &_fbb,
6822	uint32_t subgraph = `0`) {
6823	CallOptionsBuilder builder_(_fbb);
6824	builder_.add_subgraph(subgraph);
6825	return builder_.Finish();
6826	}
6827
6828	flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6829
6830	struct PadOptionsT : public flatbuffers::NativeTable {
6831	typedef PadOptions TableType;
6832	};
6833
6834	struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6835	typedef PadOptionsT NativeTableType;
6836	typedef PadOptionsBuilder Builder;
6837	bool Verify(flatbuffers::Verifier &verifier) const {
6838	return VerifyTableStart(verifier) &&
6839	verifier.EndTable();
6840	}
6841	PadOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6842	void UnPackTo(PadOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6843	static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6844	};
6845
6846	struct PadOptionsBuilder {
6847	typedef PadOptions Table;
6848	flatbuffers::FlatBufferBuilder &fbb_;
6849	flatbuffers::uoffset_t start_;
6850	explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6851	: fbb_(_fbb) {
6852	start_ = fbb_.StartTable();
6853	}
6854	flatbuffers::Offset<PadOptions> Finish() {
6855	const auto end = fbb_.EndTable(start_);
6856	auto o = flatbuffers::Offset<PadOptions>(end);
6857	return o;
6858	}
6859	};
6860
6861	inline flatbuffers::Offset<PadOptions> CreatePadOptions(
6862	flatbuffers::FlatBufferBuilder &_fbb) {
6863	PadOptionsBuilder builder_(_fbb);
6864	return builder_.Finish();
6865	}
6866
6867	flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6868
6869	struct PadV2OptionsT : public flatbuffers::NativeTable {
6870	typedef PadV2Options TableType;
6871	};
6872
6873	struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6874	typedef PadV2OptionsT NativeTableType;
6875	typedef PadV2OptionsBuilder Builder;
6876	bool Verify(flatbuffers::Verifier &verifier) const {
6877	return VerifyTableStart(verifier) &&
6878	verifier.EndTable();
6879	}
6880	PadV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6881	void UnPackTo(PadV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6882	static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6883	};
6884
6885	struct PadV2OptionsBuilder {
6886	typedef PadV2Options Table;
6887	flatbuffers::FlatBufferBuilder &fbb_;
6888	flatbuffers::uoffset_t start_;
6889	explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6890	: fbb_(_fbb) {
6891	start_ = fbb_.StartTable();
6892	}
6893	flatbuffers::Offset<PadV2Options> Finish() {
6894	const auto end = fbb_.EndTable(start_);
6895	auto o = flatbuffers::Offset<PadV2Options>(end);
6896	return o;
6897	}
6898	};
6899
6900	inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
6901	flatbuffers::FlatBufferBuilder &_fbb) {
6902	PadV2OptionsBuilder builder_(_fbb);
6903	return builder_.Finish();
6904	}
6905
6906	flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6907
6908	struct ReshapeOptionsT : public flatbuffers::NativeTable {
6909	typedef ReshapeOptions TableType;
6910	std::vector<int32_t> new_shape{};
6911	};
6912
6913	struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6914	typedef ReshapeOptionsT NativeTableType;
6915	typedef ReshapeOptionsBuilder Builder;
6916	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6917	VT_NEW_SHAPE = `4`
6918	};
6919	const flatbuffers::Vector<int32_t> new_shape() const* {
6920	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
6921	}
6922	bool Verify(flatbuffers::Verifier &verifier) const {
6923	return VerifyTableStart(verifier) &&
6924	VerifyOffset(verifier, VT_NEW_SHAPE) &&
6925	verifier.VerifyVector(new_shape()) &&
6926	verifier.EndTable();
6927	}
6928	ReshapeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6929	void UnPackTo(ReshapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6930	static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6931	};
6932
6933	struct ReshapeOptionsBuilder {
6934	typedef ReshapeOptions Table;
6935	flatbuffers::FlatBufferBuilder &fbb_;
6936	flatbuffers::uoffset_t start_;
6937	void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
6938	fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
6939	}
6940	explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6941	: fbb_(_fbb) {
6942	start_ = fbb_.StartTable();
6943	}
6944	flatbuffers::Offset<ReshapeOptions> Finish() {
6945	const auto end = fbb_.EndTable(start_);
6946	auto o = flatbuffers::Offset<ReshapeOptions>(end);
6947	return o;
6948	}
6949	};
6950
6951	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
6952	flatbuffers::FlatBufferBuilder &_fbb,
6953	flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = `0`) {
6954	ReshapeOptionsBuilder builder_(_fbb);
6955	builder_.add_new_shape(new_shape);
6956	return builder_.Finish();
6957	}
6958
6959	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
6960	flatbuffers::FlatBufferBuilder &_fbb,
6961	const std::vector<int32_t> new_shape = nullptr*) {
6962	auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : `0`;
6963	return tflite::CreateReshapeOptions(
6964	_fbb,
6965	new_shape__);
6966	}
6967
6968	flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
6969
6970	struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable {
6971	typedef SpaceToBatchNDOptions TableType;
6972	};
6973
6974	struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6975	typedef SpaceToBatchNDOptionsT NativeTableType;
6976	typedef SpaceToBatchNDOptionsBuilder Builder;
6977	bool Verify(flatbuffers::Verifier &verifier) const {
6978	return VerifyTableStart(verifier) &&
6979	verifier.EndTable();
6980	}
6981	SpaceToBatchNDOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6982	void UnPackTo(SpaceToBatchNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
6983	static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
6984	};
6985
6986	struct SpaceToBatchNDOptionsBuilder {
6987	typedef SpaceToBatchNDOptions Table;
6988	flatbuffers::FlatBufferBuilder &fbb_;
6989	flatbuffers::uoffset_t start_;
6990	explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
6991	: fbb_(_fbb) {
6992	start_ = fbb_.StartTable();
6993	}
6994	flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
6995	const auto end = fbb_.EndTable(start_);
6996	auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
6997	return o;
6998	}
6999	};
7000
7001	inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
7002	flatbuffers::FlatBufferBuilder &_fbb) {
7003	SpaceToBatchNDOptionsBuilder builder_(_fbb);
7004	return builder_.Finish();
7005	}
7006
7007	flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7008
7009	struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable {
7010	typedef BatchToSpaceNDOptions TableType;
7011	};
7012
7013	struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7014	typedef BatchToSpaceNDOptionsT NativeTableType;
7015	typedef BatchToSpaceNDOptionsBuilder Builder;
7016	bool Verify(flatbuffers::Verifier &verifier) const {
7017	return VerifyTableStart(verifier) &&
7018	verifier.EndTable();
7019	}
7020	BatchToSpaceNDOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7021	void UnPackTo(BatchToSpaceNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7022	static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7023	};
7024
7025	struct BatchToSpaceNDOptionsBuilder {
7026	typedef BatchToSpaceNDOptions Table;
7027	flatbuffers::FlatBufferBuilder &fbb_;
7028	flatbuffers::uoffset_t start_;
7029	explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7030	: fbb_(_fbb) {
7031	start_ = fbb_.StartTable();
7032	}
7033	flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
7034	const auto end = fbb_.EndTable(start_);
7035	auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
7036	return o;
7037	}
7038	};
7039
7040	inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
7041	flatbuffers::FlatBufferBuilder &_fbb) {
7042	BatchToSpaceNDOptionsBuilder builder_(_fbb);
7043	return builder_.Finish();
7044	}
7045
7046	flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7047
7048	struct SkipGramOptionsT : public flatbuffers::NativeTable {
7049	typedef SkipGramOptions TableType;
7050	int32_t ngram_size = `0`;
7051	int32_t max_skip_size = `0`;
7052	bool include_all_ngrams = false;
7053	};
7054
7055	struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7056	typedef SkipGramOptionsT NativeTableType;
7057	typedef SkipGramOptionsBuilder Builder;
7058	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7059	VT_NGRAM_SIZE = `4`,
7060	VT_MAX_SKIP_SIZE = `6`,
7061	VT_INCLUDE_ALL_NGRAMS = `8`
7062	};
7063	int32_t ngram_size() const {
7064	return GetField<int32_t>(VT_NGRAM_SIZE, `0`);
7065	}
7066	int32_t max_skip_size() const {
7067	return GetField<int32_t>(VT_MAX_SKIP_SIZE, `0`);
7068	}
7069	bool include_all_ngrams() const {
7070	return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, `0`) != `0`;
7071	}
7072	bool Verify(flatbuffers::Verifier &verifier) const {
7073	return VerifyTableStart(verifier) &&
7074	VerifyField<int32_t>(verifier, VT_NGRAM_SIZE, `4`) &&
7075	VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE, `4`) &&
7076	VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS, `1`) &&
7077	verifier.EndTable();
7078	}
7079	SkipGramOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7080	void UnPackTo(SkipGramOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7081	static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7082	};
7083
7084	struct SkipGramOptionsBuilder {
7085	typedef SkipGramOptions Table;
7086	flatbuffers::FlatBufferBuilder &fbb_;
7087	flatbuffers::uoffset_t start_;
7088	void add_ngram_size(int32_t ngram_size) {
7089	fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, `0`);
7090	}
7091	void add_max_skip_size(int32_t max_skip_size) {
7092	fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, `0`);
7093	}
7094	void add_include_all_ngrams(bool include_all_ngrams) {
7095	fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), `0`);
7096	}
7097	explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7098	: fbb_(_fbb) {
7099	start_ = fbb_.StartTable();
7100	}
7101	flatbuffers::Offset<SkipGramOptions> Finish() {
7102	const auto end = fbb_.EndTable(start_);
7103	auto o = flatbuffers::Offset<SkipGramOptions>(end);
7104	return o;
7105	}
7106	};
7107
7108	inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
7109	flatbuffers::FlatBufferBuilder &_fbb,
7110	int32_t ngram_size = `0`,
7111	int32_t max_skip_size = `0`,
7112	bool include_all_ngrams = false) {
7113	SkipGramOptionsBuilder builder_(_fbb);
7114	builder_.add_max_skip_size(max_skip_size);
7115	builder_.add_ngram_size(ngram_size);
7116	builder_.add_include_all_ngrams(include_all_ngrams);
7117	return builder_.Finish();
7118	}
7119
7120	flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7121
7122	struct SpaceToDepthOptionsT : public flatbuffers::NativeTable {
7123	typedef SpaceToDepthOptions TableType;
7124	int32_t block_size = `0`;
7125	};
7126
7127	struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7128	typedef SpaceToDepthOptionsT NativeTableType;
7129	typedef SpaceToDepthOptionsBuilder Builder;
7130	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7131	VT_BLOCK_SIZE = `4`
7132	};
7133	int32_t block_size() const {
7134	return GetField<int32_t>(VT_BLOCK_SIZE, `0`);
7135	}
7136	bool Verify(flatbuffers::Verifier &verifier) const {
7137	return VerifyTableStart(verifier) &&
7138	VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, `4`) &&
7139	verifier.EndTable();
7140	}
7141	SpaceToDepthOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7142	void UnPackTo(SpaceToDepthOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7143	static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7144	};
7145
7146	struct SpaceToDepthOptionsBuilder {
7147	typedef SpaceToDepthOptions Table;
7148	flatbuffers::FlatBufferBuilder &fbb_;
7149	flatbuffers::uoffset_t start_;
7150	void add_block_size(int32_t block_size) {
7151	fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, `0`);
7152	}
7153	explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7154	: fbb_(_fbb) {
7155	start_ = fbb_.StartTable();
7156	}
7157	flatbuffers::Offset<SpaceToDepthOptions> Finish() {
7158	const auto end = fbb_.EndTable(start_);
7159	auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
7160	return o;
7161	}
7162	};
7163
7164	inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
7165	flatbuffers::FlatBufferBuilder &_fbb,
7166	int32_t block_size = `0`) {
7167	SpaceToDepthOptionsBuilder builder_(_fbb);
7168	builder_.add_block_size(block_size);
7169	return builder_.Finish();
7170	}
7171
7172	flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7173
7174	struct DepthToSpaceOptionsT : public flatbuffers::NativeTable {
7175	typedef DepthToSpaceOptions TableType;
7176	int32_t block_size = `0`;
7177	};
7178
7179	struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7180	typedef DepthToSpaceOptionsT NativeTableType;
7181	typedef DepthToSpaceOptionsBuilder Builder;
7182	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7183	VT_BLOCK_SIZE = `4`
7184	};
7185	int32_t block_size() const {
7186	return GetField<int32_t>(VT_BLOCK_SIZE, `0`);
7187	}
7188	bool Verify(flatbuffers::Verifier &verifier) const {
7189	return VerifyTableStart(verifier) &&
7190	VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, `4`) &&
7191	verifier.EndTable();
7192	}
7193	DepthToSpaceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7194	void UnPackTo(DepthToSpaceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7195	static flatbuffers::Offset<DepthToSpaceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7196	};
7197
7198	struct DepthToSpaceOptionsBuilder {
7199	typedef DepthToSpaceOptions Table;
7200	flatbuffers::FlatBufferBuilder &fbb_;
7201	flatbuffers::uoffset_t start_;
7202	void add_block_size(int32_t block_size) {
7203	fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, `0`);
7204	}
7205	explicit DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7206	: fbb_(_fbb) {
7207	start_ = fbb_.StartTable();
7208	}
7209	flatbuffers::Offset<DepthToSpaceOptions> Finish() {
7210	const auto end = fbb_.EndTable(start_);
7211	auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
7212	return o;
7213	}
7214	};
7215
7216	inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
7217	flatbuffers::FlatBufferBuilder &_fbb,
7218	int32_t block_size = `0`) {
7219	DepthToSpaceOptionsBuilder builder_(_fbb);
7220	builder_.add_block_size(block_size);
7221	return builder_.Finish();
7222	}
7223
7224	flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7225
7226	struct SubOptionsT : public flatbuffers::NativeTable {
7227	typedef SubOptions TableType;
7228	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
7229	bool pot_scale_int16 = true;
7230	};
7231
7232	struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7233	typedef SubOptionsT NativeTableType;
7234	typedef SubOptionsBuilder Builder;
7235	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7236	VT_FUSED_ACTIVATION_FUNCTION = `4`,
7237	VT_POT_SCALE_INT16 = `6`
7238	};
7239	tflite::ActivationFunctionType fused_activation_function() const {
7240	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
7241	}
7242	bool pot_scale_int16() const {
7243	return GetField<uint8_t>(VT_POT_SCALE_INT16, `1`) != `0`;
7244	}
7245	bool Verify(flatbuffers::Verifier &verifier) const {
7246	return VerifyTableStart(verifier) &&
7247	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
7248	VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, `1`) &&
7249	verifier.EndTable();
7250	}
7251	SubOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7252	void UnPackTo(SubOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7253	static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7254	};
7255
7256	struct SubOptionsBuilder {
7257	typedef SubOptions Table;
7258	flatbuffers::FlatBufferBuilder &fbb_;
7259	flatbuffers::uoffset_t start_;
7260	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
7261	fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
7262	}
7263	void add_pot_scale_int16(bool pot_scale_int16) {
7264	fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), `1`);
7265	}
7266	explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7267	: fbb_(_fbb) {
7268	start_ = fbb_.StartTable();
7269	}
7270	flatbuffers::Offset<SubOptions> Finish() {
7271	const auto end = fbb_.EndTable(start_);
7272	auto o = flatbuffers::Offset<SubOptions>(end);
7273	return o;
7274	}
7275	};
7276
7277	inline flatbuffers::Offset<SubOptions> CreateSubOptions(
7278	flatbuffers::FlatBufferBuilder &_fbb,
7279	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE,
7280	bool pot_scale_int16 = true) {
7281	SubOptionsBuilder builder_(_fbb);
7282	builder_.add_pot_scale_int16(pot_scale_int16);
7283	builder_.add_fused_activation_function(fused_activation_function);
7284	return builder_.Finish();
7285	}
7286
7287	flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7288
7289	struct DivOptionsT : public flatbuffers::NativeTable {
7290	typedef DivOptions TableType;
7291	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE;
7292	};
7293
7294	struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7295	typedef DivOptionsT NativeTableType;
7296	typedef DivOptionsBuilder Builder;
7297	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7298	VT_FUSED_ACTIVATION_FUNCTION = `4`
7299	};
7300	tflite::ActivationFunctionType fused_activation_function() const {
7301	return static_cast<tflite::ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, `0`));
7302	}
7303	bool Verify(flatbuffers::Verifier &verifier) const {
7304	return VerifyTableStart(verifier) &&
7305	VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, `1`) &&
7306	verifier.EndTable();
7307	}
7308	DivOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7309	void UnPackTo(DivOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7310	static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7311	};
7312
7313	struct DivOptionsBuilder {
7314	typedef DivOptions Table;
7315	flatbuffers::FlatBufferBuilder &fbb_;
7316	flatbuffers::uoffset_t start_;
7317	void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function) {
7318	fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), `0`);
7319	}
7320	explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7321	: fbb_(_fbb) {
7322	start_ = fbb_.StartTable();
7323	}
7324	flatbuffers::Offset<DivOptions> Finish() {
7325	const auto end = fbb_.EndTable(start_);
7326	auto o = flatbuffers::Offset<DivOptions>(end);
7327	return o;
7328	}
7329	};
7330
7331	inline flatbuffers::Offset<DivOptions> CreateDivOptions(
7332	flatbuffers::FlatBufferBuilder &_fbb,
7333	tflite::ActivationFunctionType fused_activation_function = tflite::ActivationFunctionType_NONE) {
7334	DivOptionsBuilder builder_(_fbb);
7335	builder_.add_fused_activation_function(fused_activation_function);
7336	return builder_.Finish();
7337	}
7338
7339	flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7340
7341	struct TopKV2OptionsT : public flatbuffers::NativeTable {
7342	typedef TopKV2Options TableType;
7343	};
7344
7345	struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7346	typedef TopKV2OptionsT NativeTableType;
7347	typedef TopKV2OptionsBuilder Builder;
7348	bool Verify(flatbuffers::Verifier &verifier) const {
7349	return VerifyTableStart(verifier) &&
7350	verifier.EndTable();
7351	}
7352	TopKV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7353	void UnPackTo(TopKV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7354	static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7355	};
7356
7357	struct TopKV2OptionsBuilder {
7358	typedef TopKV2Options Table;
7359	flatbuffers::FlatBufferBuilder &fbb_;
7360	flatbuffers::uoffset_t start_;
7361	explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7362	: fbb_(_fbb) {
7363	start_ = fbb_.StartTable();
7364	}
7365	flatbuffers::Offset<TopKV2Options> Finish() {
7366	const auto end = fbb_.EndTable(start_);
7367	auto o = flatbuffers::Offset<TopKV2Options>(end);
7368	return o;
7369	}
7370	};
7371
7372	inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
7373	flatbuffers::FlatBufferBuilder &_fbb) {
7374	TopKV2OptionsBuilder builder_(_fbb);
7375	return builder_.Finish();
7376	}
7377
7378	flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7379
7380	struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
7381	typedef EmbeddingLookupSparseOptions TableType;
7382	tflite::CombinerType combiner = tflite::CombinerType_SUM;
7383	};
7384
7385	struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7386	typedef EmbeddingLookupSparseOptionsT NativeTableType;
7387	typedef EmbeddingLookupSparseOptionsBuilder Builder;
7388	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7389	VT_COMBINER = `4`
7390	};
7391	tflite::CombinerType combiner() const {
7392	return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, `0`));
7393	}
7394	bool Verify(flatbuffers::Verifier &verifier) const {
7395	return VerifyTableStart(verifier) &&
7396	VerifyField<int8_t>(verifier, VT_COMBINER, `1`) &&
7397	verifier.EndTable();
7398	}
7399	EmbeddingLookupSparseOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7400	void UnPackTo(EmbeddingLookupSparseOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7401	static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7402	};
7403
7404	struct EmbeddingLookupSparseOptionsBuilder {
7405	typedef EmbeddingLookupSparseOptions Table;
7406	flatbuffers::FlatBufferBuilder &fbb_;
7407	flatbuffers::uoffset_t start_;
7408	void add_combiner(tflite::CombinerType combiner) {
7409	fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), `0`);
7410	}
7411	explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7412	: fbb_(_fbb) {
7413	start_ = fbb_.StartTable();
7414	}
7415	flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
7416	const auto end = fbb_.EndTable(start_);
7417	auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
7418	return o;
7419	}
7420	};
7421
7422	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
7423	flatbuffers::FlatBufferBuilder &_fbb,
7424	tflite::CombinerType combiner = tflite::CombinerType_SUM) {
7425	EmbeddingLookupSparseOptionsBuilder builder_(_fbb);
7426	builder_.add_combiner(combiner);
7427	return builder_.Finish();
7428	}
7429
7430	flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7431
7432	struct GatherOptionsT : public flatbuffers::NativeTable {
7433	typedef GatherOptions TableType;
7434	int32_t axis = `0`;
7435	int32_t batch_dims = `0`;
7436	};
7437
7438	struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7439	typedef GatherOptionsT NativeTableType;
7440	typedef GatherOptionsBuilder Builder;
7441	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7442	VT_AXIS = `4`,
7443	VT_BATCH_DIMS = `6`
7444	};
7445	int32_t axis() const {
7446	return GetField<int32_t>(VT_AXIS, `0`);
7447	}
7448	int32_t batch_dims() const {
7449	return GetField<int32_t>(VT_BATCH_DIMS, `0`);
7450	}
7451	bool Verify(flatbuffers::Verifier &verifier) const {
7452	return VerifyTableStart(verifier) &&
7453	VerifyField<int32_t>(verifier, VT_AXIS, `4`) &&
7454	VerifyField<int32_t>(verifier, VT_BATCH_DIMS, `4`) &&
7455	verifier.EndTable();
7456	}
7457	GatherOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7458	void UnPackTo(GatherOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7459	static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7460	};
7461
7462	struct GatherOptionsBuilder {
7463	typedef GatherOptions Table;
7464	flatbuffers::FlatBufferBuilder &fbb_;
7465	flatbuffers::uoffset_t start_;
7466	void add_axis(int32_t axis) {
7467	fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, `0`);
7468	}
7469	void add_batch_dims(int32_t batch_dims) {
7470	fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, `0`);
7471	}
7472	explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7473	: fbb_(_fbb) {
7474	start_ = fbb_.StartTable();
7475	}
7476	flatbuffers::Offset<GatherOptions> Finish() {
7477	const auto end = fbb_.EndTable(start_);
7478	auto o = flatbuffers::Offset<GatherOptions>(end);
7479	return o;
7480	}
7481	};
7482
7483	inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
7484	flatbuffers::FlatBufferBuilder &_fbb,
7485	int32_t axis = `0`,
7486	int32_t batch_dims = `0`) {
7487	GatherOptionsBuilder builder_(_fbb);
7488	builder_.add_batch_dims(batch_dims);
7489	builder_.add_axis(axis);
7490	return builder_.Finish();
7491	}
7492
7493	flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7494
7495	struct TransposeOptionsT : public flatbuffers::NativeTable {
7496	typedef TransposeOptions TableType;
7497	};
7498
7499	struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7500	typedef TransposeOptionsT NativeTableType;
7501	typedef TransposeOptionsBuilder Builder;
7502	bool Verify(flatbuffers::Verifier &verifier) const {
7503	return VerifyTableStart(verifier) &&
7504	verifier.EndTable();
7505	}
7506	TransposeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7507	void UnPackTo(TransposeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7508	static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7509	};
7510
7511	struct TransposeOptionsBuilder {
7512	typedef TransposeOptions Table;
7513	flatbuffers::FlatBufferBuilder &fbb_;
7514	flatbuffers::uoffset_t start_;
7515	explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7516	: fbb_(_fbb) {
7517	start_ = fbb_.StartTable();
7518	}
7519	flatbuffers::Offset<TransposeOptions> Finish() {
7520	const auto end = fbb_.EndTable(start_);
7521	auto o = flatbuffers::Offset<TransposeOptions>(end);
7522	return o;
7523	}
7524	};
7525
7526	inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
7527	flatbuffers::FlatBufferBuilder &_fbb) {
7528	TransposeOptionsBuilder builder_(_fbb);
7529	return builder_.Finish();
7530	}
7531
7532	flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7533
7534	struct ExpOptionsT : public flatbuffers::NativeTable {
7535	typedef ExpOptions TableType;
7536	};
7537
7538	struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7539	typedef ExpOptionsT NativeTableType;
7540	typedef ExpOptionsBuilder Builder;
7541	bool Verify(flatbuffers::Verifier &verifier) const {
7542	return VerifyTableStart(verifier) &&
7543	verifier.EndTable();
7544	}
7545	ExpOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7546	void UnPackTo(ExpOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7547	static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7548	};
7549
7550	struct ExpOptionsBuilder {
7551	typedef ExpOptions Table;
7552	flatbuffers::FlatBufferBuilder &fbb_;
7553	flatbuffers::uoffset_t start_;
7554	explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7555	: fbb_(_fbb) {
7556	start_ = fbb_.StartTable();
7557	}
7558	flatbuffers::Offset<ExpOptions> Finish() {
7559	const auto end = fbb_.EndTable(start_);
7560	auto o = flatbuffers::Offset<ExpOptions>(end);
7561	return o;
7562	}
7563	};
7564
7565	inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
7566	flatbuffers::FlatBufferBuilder &_fbb) {
7567	ExpOptionsBuilder builder_(_fbb);
7568	return builder_.Finish();
7569	}
7570
7571	flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7572
7573	struct CosOptionsT : public flatbuffers::NativeTable {
7574	typedef CosOptions TableType;
7575	};
7576
7577	struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7578	typedef CosOptionsT NativeTableType;
7579	typedef CosOptionsBuilder Builder;
7580	bool Verify(flatbuffers::Verifier &verifier) const {
7581	return VerifyTableStart(verifier) &&
7582	verifier.EndTable();
7583	}
7584	CosOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7585	void UnPackTo(CosOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7586	static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7587	};
7588
7589	struct CosOptionsBuilder {
7590	typedef CosOptions Table;
7591	flatbuffers::FlatBufferBuilder &fbb_;
7592	flatbuffers::uoffset_t start_;
7593	explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7594	: fbb_(_fbb) {
7595	start_ = fbb_.StartTable();
7596	}
7597	flatbuffers::Offset<CosOptions> Finish() {
7598	const auto end = fbb_.EndTable(start_);
7599	auto o = flatbuffers::Offset<CosOptions>(end);
7600	return o;
7601	}
7602	};
7603
7604	inline flatbuffers::Offset<CosOptions> CreateCosOptions(
7605	flatbuffers::FlatBufferBuilder &_fbb) {
7606	CosOptionsBuilder builder_(_fbb);
7607	return builder_.Finish();
7608	}
7609
7610	flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7611
7612	struct ReducerOptionsT : public flatbuffers::NativeTable {
7613	typedef ReducerOptions TableType;
7614	bool keep_dims = false;
7615	};
7616
7617	struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7618	typedef ReducerOptionsT NativeTableType;
7619	typedef ReducerOptionsBuilder Builder;
7620	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7621	VT_KEEP_DIMS = `4`
7622	};
7623	bool keep_dims() const {
7624	return GetField<uint8_t>(VT_KEEP_DIMS, `0`) != `0`;
7625	}
7626	bool Verify(flatbuffers::Verifier &verifier) const {
7627	return VerifyTableStart(verifier) &&
7628	VerifyField<uint8_t>(verifier, VT_KEEP_DIMS, `1`) &&
7629	verifier.EndTable();
7630	}
7631	ReducerOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7632	void UnPackTo(ReducerOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7633	static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7634	};
7635
7636	struct ReducerOptionsBuilder {
7637	typedef ReducerOptions Table;
7638	flatbuffers::FlatBufferBuilder &fbb_;
7639	flatbuffers::uoffset_t start_;
7640	void add_keep_dims(bool keep_dims) {
7641	fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), `0`);
7642	}
7643	explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7644	: fbb_(_fbb) {
7645	start_ = fbb_.StartTable();
7646	}
7647	flatbuffers::Offset<ReducerOptions> Finish() {
7648	const auto end = fbb_.EndTable(start_);
7649	auto o = flatbuffers::Offset<ReducerOptions>(end);
7650	return o;
7651	}
7652	};
7653
7654	inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
7655	flatbuffers::FlatBufferBuilder &_fbb,
7656	bool keep_dims = false) {
7657	ReducerOptionsBuilder builder_(_fbb);
7658	builder_.add_keep_dims(keep_dims);
7659	return builder_.Finish();
7660	}
7661
7662	flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7663
7664	struct SqueezeOptionsT : public flatbuffers::NativeTable {
7665	typedef SqueezeOptions TableType;
7666	std::vector<int32_t> squeeze_dims{};
7667	};
7668
7669	struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7670	typedef SqueezeOptionsT NativeTableType;
7671	typedef SqueezeOptionsBuilder Builder;
7672	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7673	VT_SQUEEZE_DIMS = `4`
7674	};
7675	const flatbuffers::Vector<int32_t> squeeze_dims() const* {
7676	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
7677	}
7678	bool Verify(flatbuffers::Verifier &verifier) const {
7679	return VerifyTableStart(verifier) &&
7680	VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
7681	verifier.VerifyVector(squeeze_dims()) &&
7682	verifier.EndTable();
7683	}
7684	SqueezeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7685	void UnPackTo(SqueezeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7686	static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7687	};
7688
7689	struct SqueezeOptionsBuilder {
7690	typedef SqueezeOptions Table;
7691	flatbuffers::FlatBufferBuilder &fbb_;
7692	flatbuffers::uoffset_t start_;
7693	void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
7694	fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
7695	}
7696	explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7697	: fbb_(_fbb) {
7698	start_ = fbb_.StartTable();
7699	}
7700	flatbuffers::Offset<SqueezeOptions> Finish() {
7701	const auto end = fbb_.EndTable(start_);
7702	auto o = flatbuffers::Offset<SqueezeOptions>(end);
7703	return o;
7704	}
7705	};
7706
7707	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
7708	flatbuffers::FlatBufferBuilder &_fbb,
7709	flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = `0`) {
7710	SqueezeOptionsBuilder builder_(_fbb);
7711	builder_.add_squeeze_dims(squeeze_dims);
7712	return builder_.Finish();
7713	}
7714
7715	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
7716	flatbuffers::FlatBufferBuilder &_fbb,
7717	const std::vector<int32_t> squeeze_dims = nullptr*) {
7718	auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : `0`;
7719	return tflite::CreateSqueezeOptions(
7720	_fbb,
7721	squeeze_dims__);
7722	}
7723
7724	flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7725
7726	struct SplitOptionsT : public flatbuffers::NativeTable {
7727	typedef SplitOptions TableType;
7728	int32_t num_splits = `0`;
7729	};
7730
7731	struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7732	typedef SplitOptionsT NativeTableType;
7733	typedef SplitOptionsBuilder Builder;
7734	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7735	VT_NUM_SPLITS = `4`
7736	};
7737	int32_t num_splits() const {
7738	return GetField<int32_t>(VT_NUM_SPLITS, `0`);
7739	}
7740	bool Verify(flatbuffers::Verifier &verifier) const {
7741	return VerifyTableStart(verifier) &&
7742	VerifyField<int32_t>(verifier, VT_NUM_SPLITS, `4`) &&
7743	verifier.EndTable();
7744	}
7745	SplitOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7746	void UnPackTo(SplitOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7747	static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7748	};
7749
7750	struct SplitOptionsBuilder {
7751	typedef SplitOptions Table;
7752	flatbuffers::FlatBufferBuilder &fbb_;
7753	flatbuffers::uoffset_t start_;
7754	void add_num_splits(int32_t num_splits) {
7755	fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, `0`);
7756	}
7757	explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7758	: fbb_(_fbb) {
7759	start_ = fbb_.StartTable();
7760	}
7761	flatbuffers::Offset<SplitOptions> Finish() {
7762	const auto end = fbb_.EndTable(start_);
7763	auto o = flatbuffers::Offset<SplitOptions>(end);
7764	return o;
7765	}
7766	};
7767
7768	inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
7769	flatbuffers::FlatBufferBuilder &_fbb,
7770	int32_t num_splits = `0`) {
7771	SplitOptionsBuilder builder_(_fbb);
7772	builder_.add_num_splits(num_splits);
7773	return builder_.Finish();
7774	}
7775
7776	flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7777
7778	struct SplitVOptionsT : public flatbuffers::NativeTable {
7779	typedef SplitVOptions TableType;
7780	int32_t num_splits = `0`;
7781	};
7782
7783	struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7784	typedef SplitVOptionsT NativeTableType;
7785	typedef SplitVOptionsBuilder Builder;
7786	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7787	VT_NUM_SPLITS = `4`
7788	};
7789	int32_t num_splits() const {
7790	return GetField<int32_t>(VT_NUM_SPLITS, `0`);
7791	}
7792	bool Verify(flatbuffers::Verifier &verifier) const {
7793	return VerifyTableStart(verifier) &&
7794	VerifyField<int32_t>(verifier, VT_NUM_SPLITS, `4`) &&
7795	verifier.EndTable();
7796	}
7797	SplitVOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7798	void UnPackTo(SplitVOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7799	static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7800	};
7801
7802	struct SplitVOptionsBuilder {
7803	typedef SplitVOptions Table;
7804	flatbuffers::FlatBufferBuilder &fbb_;
7805	flatbuffers::uoffset_t start_;
7806	void add_num_splits(int32_t num_splits) {
7807	fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, `0`);
7808	}
7809	explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7810	: fbb_(_fbb) {
7811	start_ = fbb_.StartTable();
7812	}
7813	flatbuffers::Offset<SplitVOptions> Finish() {
7814	const auto end = fbb_.EndTable(start_);
7815	auto o = flatbuffers::Offset<SplitVOptions>(end);
7816	return o;
7817	}
7818	};
7819
7820	inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
7821	flatbuffers::FlatBufferBuilder &_fbb,
7822	int32_t num_splits = `0`) {
7823	SplitVOptionsBuilder builder_(_fbb);
7824	builder_.add_num_splits(num_splits);
7825	return builder_.Finish();
7826	}
7827
7828	flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7829
7830	struct StridedSliceOptionsT : public flatbuffers::NativeTable {
7831	typedef StridedSliceOptions TableType;
7832	int32_t begin_mask = `0`;
7833	int32_t end_mask = `0`;
7834	int32_t ellipsis_mask = `0`;
7835	int32_t new_axis_mask = `0`;
7836	int32_t shrink_axis_mask = `0`;
7837	};
7838
7839	struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7840	typedef StridedSliceOptionsT NativeTableType;
7841	typedef StridedSliceOptionsBuilder Builder;
7842	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7843	VT_BEGIN_MASK = `4`,
7844	VT_END_MASK = `6`,
7845	VT_ELLIPSIS_MASK = `8`,
7846	VT_NEW_AXIS_MASK = `10`,
7847	VT_SHRINK_AXIS_MASK = `12`
7848	};
7849	int32_t begin_mask() const {
7850	return GetField<int32_t>(VT_BEGIN_MASK, `0`);
7851	}
7852	int32_t end_mask() const {
7853	return GetField<int32_t>(VT_END_MASK, `0`);
7854	}
7855	int32_t ellipsis_mask() const {
7856	return GetField<int32_t>(VT_ELLIPSIS_MASK, `0`);
7857	}
7858	int32_t new_axis_mask() const {
7859	return GetField<int32_t>(VT_NEW_AXIS_MASK, `0`);
7860	}
7861	int32_t shrink_axis_mask() const {
7862	return GetField<int32_t>(VT_SHRINK_AXIS_MASK, `0`);
7863	}
7864	bool Verify(flatbuffers::Verifier &verifier) const {
7865	return VerifyTableStart(verifier) &&
7866	VerifyField<int32_t>(verifier, VT_BEGIN_MASK, `4`) &&
7867	VerifyField<int32_t>(verifier, VT_END_MASK, `4`) &&
7868	VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK, `4`) &&
7869	VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK, `4`) &&
7870	VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK, `4`) &&
7871	verifier.EndTable();
7872	}
7873	StridedSliceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7874	void UnPackTo(StridedSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7875	static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7876	};
7877
7878	struct StridedSliceOptionsBuilder {
7879	typedef StridedSliceOptions Table;
7880	flatbuffers::FlatBufferBuilder &fbb_;
7881	flatbuffers::uoffset_t start_;
7882	void add_begin_mask(int32_t begin_mask) {
7883	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, `0`);
7884	}
7885	void add_end_mask(int32_t end_mask) {
7886	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, `0`);
7887	}
7888	void add_ellipsis_mask(int32_t ellipsis_mask) {
7889	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, `0`);
7890	}
7891	void add_new_axis_mask(int32_t new_axis_mask) {
7892	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, `0`);
7893	}
7894	void add_shrink_axis_mask(int32_t shrink_axis_mask) {
7895	fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, `0`);
7896	}
7897	explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7898	: fbb_(_fbb) {
7899	start_ = fbb_.StartTable();
7900	}
7901	flatbuffers::Offset<StridedSliceOptions> Finish() {
7902	const auto end = fbb_.EndTable(start_);
7903	auto o = flatbuffers::Offset<StridedSliceOptions>(end);
7904	return o;
7905	}
7906	};
7907
7908	inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
7909	flatbuffers::FlatBufferBuilder &_fbb,
7910	int32_t begin_mask = `0`,
7911	int32_t end_mask = `0`,
7912	int32_t ellipsis_mask = `0`,
7913	int32_t new_axis_mask = `0`,
7914	int32_t shrink_axis_mask = `0`) {
7915	StridedSliceOptionsBuilder builder_(_fbb);
7916	builder_.add_shrink_axis_mask(shrink_axis_mask);
7917	builder_.add_new_axis_mask(new_axis_mask);
7918	builder_.add_ellipsis_mask(ellipsis_mask);
7919	builder_.add_end_mask(end_mask);
7920	builder_.add_begin_mask(begin_mask);
7921	return builder_.Finish();
7922	}
7923
7924	flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7925
7926	struct LogSoftmaxOptionsT : public flatbuffers::NativeTable {
7927	typedef LogSoftmaxOptions TableType;
7928	};
7929
7930	struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7931	typedef LogSoftmaxOptionsT NativeTableType;
7932	typedef LogSoftmaxOptionsBuilder Builder;
7933	bool Verify(flatbuffers::Verifier &verifier) const {
7934	return VerifyTableStart(verifier) &&
7935	verifier.EndTable();
7936	}
7937	LogSoftmaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7938	void UnPackTo(LogSoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7939	static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7940	};
7941
7942	struct LogSoftmaxOptionsBuilder {
7943	typedef LogSoftmaxOptions Table;
7944	flatbuffers::FlatBufferBuilder &fbb_;
7945	flatbuffers::uoffset_t start_;
7946	explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
7947	: fbb_(_fbb) {
7948	start_ = fbb_.StartTable();
7949	}
7950	flatbuffers::Offset<LogSoftmaxOptions> Finish() {
7951	const auto end = fbb_.EndTable(start_);
7952	auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
7953	return o;
7954	}
7955	};
7956
7957	inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
7958	flatbuffers::FlatBufferBuilder &_fbb) {
7959	LogSoftmaxOptionsBuilder builder_(_fbb);
7960	return builder_.Finish();
7961	}
7962
7963	flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
7964
7965	struct CastOptionsT : public flatbuffers::NativeTable {
7966	typedef CastOptions TableType;
7967	tflite::TensorType in_data_type = tflite::TensorType_FLOAT32;
7968	tflite::TensorType out_data_type = tflite::TensorType_FLOAT32;
7969	};
7970
7971	struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7972	typedef CastOptionsT NativeTableType;
7973	typedef CastOptionsBuilder Builder;
7974	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7975	VT_IN_DATA_TYPE = `4`,
7976	VT_OUT_DATA_TYPE = `6`
7977	};
7978	tflite::TensorType in_data_type() const {
7979	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, `0`));
7980	}
7981	tflite::TensorType out_data_type() const {
7982	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, `0`));
7983	}
7984	bool Verify(flatbuffers::Verifier &verifier) const {
7985	return VerifyTableStart(verifier) &&
7986	VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE, `1`) &&
7987	VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE, `1`) &&
7988	verifier.EndTable();
7989	}
7990	CastOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7991	void UnPackTo(CastOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
7992	static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
7993	};
7994
7995	struct CastOptionsBuilder {
7996	typedef CastOptions Table;
7997	flatbuffers::FlatBufferBuilder &fbb_;
7998	flatbuffers::uoffset_t start_;
7999	void add_in_data_type(tflite::TensorType in_data_type) {
8000	fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), `0`);
8001	}
8002	void add_out_data_type(tflite::TensorType out_data_type) {
8003	fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), `0`);
8004	}
8005	explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8006	: fbb_(_fbb) {
8007	start_ = fbb_.StartTable();
8008	}
8009	flatbuffers::Offset<CastOptions> Finish() {
8010	const auto end = fbb_.EndTable(start_);
8011	auto o = flatbuffers::Offset<CastOptions>(end);
8012	return o;
8013	}
8014	};
8015
8016	inline flatbuffers::Offset<CastOptions> CreateCastOptions(
8017	flatbuffers::FlatBufferBuilder &_fbb,
8018	tflite::TensorType in_data_type = tflite::TensorType_FLOAT32,
8019	tflite::TensorType out_data_type = tflite::TensorType_FLOAT32) {
8020	CastOptionsBuilder builder_(_fbb);
8021	builder_.add_out_data_type(out_data_type);
8022	builder_.add_in_data_type(in_data_type);
8023	return builder_.Finish();
8024	}
8025
8026	flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8027
8028	struct DequantizeOptionsT : public flatbuffers::NativeTable {
8029	typedef DequantizeOptions TableType;
8030	};
8031
8032	struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8033	typedef DequantizeOptionsT NativeTableType;
8034	typedef DequantizeOptionsBuilder Builder;
8035	bool Verify(flatbuffers::Verifier &verifier) const {
8036	return VerifyTableStart(verifier) &&
8037	verifier.EndTable();
8038	}
8039	DequantizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8040	void UnPackTo(DequantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8041	static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8042	};
8043
8044	struct DequantizeOptionsBuilder {
8045	typedef DequantizeOptions Table;
8046	flatbuffers::FlatBufferBuilder &fbb_;
8047	flatbuffers::uoffset_t start_;
8048	explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8049	: fbb_(_fbb) {
8050	start_ = fbb_.StartTable();
8051	}
8052	flatbuffers::Offset<DequantizeOptions> Finish() {
8053	const auto end = fbb_.EndTable(start_);
8054	auto o = flatbuffers::Offset<DequantizeOptions>(end);
8055	return o;
8056	}
8057	};
8058
8059	inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
8060	flatbuffers::FlatBufferBuilder &_fbb) {
8061	DequantizeOptionsBuilder builder_(_fbb);
8062	return builder_.Finish();
8063	}
8064
8065	flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8066
8067	struct MaximumMinimumOptionsT : public flatbuffers::NativeTable {
8068	typedef MaximumMinimumOptions TableType;
8069	};
8070
8071	struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8072	typedef MaximumMinimumOptionsT NativeTableType;
8073	typedef MaximumMinimumOptionsBuilder Builder;
8074	bool Verify(flatbuffers::Verifier &verifier) const {
8075	return VerifyTableStart(verifier) &&
8076	verifier.EndTable();
8077	}
8078	MaximumMinimumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8079	void UnPackTo(MaximumMinimumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8080	static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8081	};
8082
8083	struct MaximumMinimumOptionsBuilder {
8084	typedef MaximumMinimumOptions Table;
8085	flatbuffers::FlatBufferBuilder &fbb_;
8086	flatbuffers::uoffset_t start_;
8087	explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8088	: fbb_(_fbb) {
8089	start_ = fbb_.StartTable();
8090	}
8091	flatbuffers::Offset<MaximumMinimumOptions> Finish() {
8092	const auto end = fbb_.EndTable(start_);
8093	auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
8094	return o;
8095	}
8096	};
8097
8098	inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
8099	flatbuffers::FlatBufferBuilder &_fbb) {
8100	MaximumMinimumOptionsBuilder builder_(_fbb);
8101	return builder_.Finish();
8102	}
8103
8104	flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8105
8106	struct TileOptionsT : public flatbuffers::NativeTable {
8107	typedef TileOptions TableType;
8108	};
8109
8110	struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8111	typedef TileOptionsT NativeTableType;
8112	typedef TileOptionsBuilder Builder;
8113	bool Verify(flatbuffers::Verifier &verifier) const {
8114	return VerifyTableStart(verifier) &&
8115	verifier.EndTable();
8116	}
8117	TileOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8118	void UnPackTo(TileOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8119	static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8120	};
8121
8122	struct TileOptionsBuilder {
8123	typedef TileOptions Table;
8124	flatbuffers::FlatBufferBuilder &fbb_;
8125	flatbuffers::uoffset_t start_;
8126	explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8127	: fbb_(_fbb) {
8128	start_ = fbb_.StartTable();
8129	}
8130	flatbuffers::Offset<TileOptions> Finish() {
8131	const auto end = fbb_.EndTable(start_);
8132	auto o = flatbuffers::Offset<TileOptions>(end);
8133	return o;
8134	}
8135	};
8136
8137	inline flatbuffers::Offset<TileOptions> CreateTileOptions(
8138	flatbuffers::FlatBufferBuilder &_fbb) {
8139	TileOptionsBuilder builder_(_fbb);
8140	return builder_.Finish();
8141	}
8142
8143	flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8144
8145	struct ArgMaxOptionsT : public flatbuffers::NativeTable {
8146	typedef ArgMaxOptions TableType;
8147	tflite::TensorType output_type = tflite::TensorType_FLOAT32;
8148	};
8149
8150	struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8151	typedef ArgMaxOptionsT NativeTableType;
8152	typedef ArgMaxOptionsBuilder Builder;
8153	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8154	VT_OUTPUT_TYPE = `4`
8155	};
8156	tflite::TensorType output_type() const {
8157	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, `0`));
8158	}
8159	bool Verify(flatbuffers::Verifier &verifier) const {
8160	return VerifyTableStart(verifier) &&
8161	VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, `1`) &&
8162	verifier.EndTable();
8163	}
8164	ArgMaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8165	void UnPackTo(ArgMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8166	static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8167	};
8168
8169	struct ArgMaxOptionsBuilder {
8170	typedef ArgMaxOptions Table;
8171	flatbuffers::FlatBufferBuilder &fbb_;
8172	flatbuffers::uoffset_t start_;
8173	void add_output_type(tflite::TensorType output_type) {
8174	fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), `0`);
8175	}
8176	explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8177	: fbb_(_fbb) {
8178	start_ = fbb_.StartTable();
8179	}
8180	flatbuffers::Offset<ArgMaxOptions> Finish() {
8181	const auto end = fbb_.EndTable(start_);
8182	auto o = flatbuffers::Offset<ArgMaxOptions>(end);
8183	return o;
8184	}
8185	};
8186
8187	inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
8188	flatbuffers::FlatBufferBuilder &_fbb,
8189	tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
8190	ArgMaxOptionsBuilder builder_(_fbb);
8191	builder_.add_output_type(output_type);
8192	return builder_.Finish();
8193	}
8194
8195	flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8196
8197	struct ArgMinOptionsT : public flatbuffers::NativeTable {
8198	typedef ArgMinOptions TableType;
8199	tflite::TensorType output_type = tflite::TensorType_FLOAT32;
8200	};
8201
8202	struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8203	typedef ArgMinOptionsT NativeTableType;
8204	typedef ArgMinOptionsBuilder Builder;
8205	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8206	VT_OUTPUT_TYPE = `4`
8207	};
8208	tflite::TensorType output_type() const {
8209	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, `0`));
8210	}
8211	bool Verify(flatbuffers::Verifier &verifier) const {
8212	return VerifyTableStart(verifier) &&
8213	VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, `1`) &&
8214	verifier.EndTable();
8215	}
8216	ArgMinOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8217	void UnPackTo(ArgMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8218	static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8219	};
8220
8221	struct ArgMinOptionsBuilder {
8222	typedef ArgMinOptions Table;
8223	flatbuffers::FlatBufferBuilder &fbb_;
8224	flatbuffers::uoffset_t start_;
8225	void add_output_type(tflite::TensorType output_type) {
8226	fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), `0`);
8227	}
8228	explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8229	: fbb_(_fbb) {
8230	start_ = fbb_.StartTable();
8231	}
8232	flatbuffers::Offset<ArgMinOptions> Finish() {
8233	const auto end = fbb_.EndTable(start_);
8234	auto o = flatbuffers::Offset<ArgMinOptions>(end);
8235	return o;
8236	}
8237	};
8238
8239	inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
8240	flatbuffers::FlatBufferBuilder &_fbb,
8241	tflite::TensorType output_type = tflite::TensorType_FLOAT32) {
8242	ArgMinOptionsBuilder builder_(_fbb);
8243	builder_.add_output_type(output_type);
8244	return builder_.Finish();
8245	}
8246
8247	flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8248
8249	struct GreaterOptionsT : public flatbuffers::NativeTable {
8250	typedef GreaterOptions TableType;
8251	};
8252
8253	struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8254	typedef GreaterOptionsT NativeTableType;
8255	typedef GreaterOptionsBuilder Builder;
8256	bool Verify(flatbuffers::Verifier &verifier) const {
8257	return VerifyTableStart(verifier) &&
8258	verifier.EndTable();
8259	}
8260	GreaterOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8261	void UnPackTo(GreaterOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8262	static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8263	};
8264
8265	struct GreaterOptionsBuilder {
8266	typedef GreaterOptions Table;
8267	flatbuffers::FlatBufferBuilder &fbb_;
8268	flatbuffers::uoffset_t start_;
8269	explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8270	: fbb_(_fbb) {
8271	start_ = fbb_.StartTable();
8272	}
8273	flatbuffers::Offset<GreaterOptions> Finish() {
8274	const auto end = fbb_.EndTable(start_);
8275	auto o = flatbuffers::Offset<GreaterOptions>(end);
8276	return o;
8277	}
8278	};
8279
8280	inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
8281	flatbuffers::FlatBufferBuilder &_fbb) {
8282	GreaterOptionsBuilder builder_(_fbb);
8283	return builder_.Finish();
8284	}
8285
8286	flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8287
8288	struct GreaterEqualOptionsT : public flatbuffers::NativeTable {
8289	typedef GreaterEqualOptions TableType;
8290	};
8291
8292	struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8293	typedef GreaterEqualOptionsT NativeTableType;
8294	typedef GreaterEqualOptionsBuilder Builder;
8295	bool Verify(flatbuffers::Verifier &verifier) const {
8296	return VerifyTableStart(verifier) &&
8297	verifier.EndTable();
8298	}
8299	GreaterEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8300	void UnPackTo(GreaterEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8301	static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8302	};
8303
8304	struct GreaterEqualOptionsBuilder {
8305	typedef GreaterEqualOptions Table;
8306	flatbuffers::FlatBufferBuilder &fbb_;
8307	flatbuffers::uoffset_t start_;
8308	explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8309	: fbb_(_fbb) {
8310	start_ = fbb_.StartTable();
8311	}
8312	flatbuffers::Offset<GreaterEqualOptions> Finish() {
8313	const auto end = fbb_.EndTable(start_);
8314	auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
8315	return o;
8316	}
8317	};
8318
8319	inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
8320	flatbuffers::FlatBufferBuilder &_fbb) {
8321	GreaterEqualOptionsBuilder builder_(_fbb);
8322	return builder_.Finish();
8323	}
8324
8325	flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8326
8327	struct LessOptionsT : public flatbuffers::NativeTable {
8328	typedef LessOptions TableType;
8329	};
8330
8331	struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8332	typedef LessOptionsT NativeTableType;
8333	typedef LessOptionsBuilder Builder;
8334	bool Verify(flatbuffers::Verifier &verifier) const {
8335	return VerifyTableStart(verifier) &&
8336	verifier.EndTable();
8337	}
8338	LessOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8339	void UnPackTo(LessOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8340	static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8341	};
8342
8343	struct LessOptionsBuilder {
8344	typedef LessOptions Table;
8345	flatbuffers::FlatBufferBuilder &fbb_;
8346	flatbuffers::uoffset_t start_;
8347	explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8348	: fbb_(_fbb) {
8349	start_ = fbb_.StartTable();
8350	}
8351	flatbuffers::Offset<LessOptions> Finish() {
8352	const auto end = fbb_.EndTable(start_);
8353	auto o = flatbuffers::Offset<LessOptions>(end);
8354	return o;
8355	}
8356	};
8357
8358	inline flatbuffers::Offset<LessOptions> CreateLessOptions(
8359	flatbuffers::FlatBufferBuilder &_fbb) {
8360	LessOptionsBuilder builder_(_fbb);
8361	return builder_.Finish();
8362	}
8363
8364	flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8365
8366	struct LessEqualOptionsT : public flatbuffers::NativeTable {
8367	typedef LessEqualOptions TableType;
8368	};
8369
8370	struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8371	typedef LessEqualOptionsT NativeTableType;
8372	typedef LessEqualOptionsBuilder Builder;
8373	bool Verify(flatbuffers::Verifier &verifier) const {
8374	return VerifyTableStart(verifier) &&
8375	verifier.EndTable();
8376	}
8377	LessEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8378	void UnPackTo(LessEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8379	static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8380	};
8381
8382	struct LessEqualOptionsBuilder {
8383	typedef LessEqualOptions Table;
8384	flatbuffers::FlatBufferBuilder &fbb_;
8385	flatbuffers::uoffset_t start_;
8386	explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8387	: fbb_(_fbb) {
8388	start_ = fbb_.StartTable();
8389	}
8390	flatbuffers::Offset<LessEqualOptions> Finish() {
8391	const auto end = fbb_.EndTable(start_);
8392	auto o = flatbuffers::Offset<LessEqualOptions>(end);
8393	return o;
8394	}
8395	};
8396
8397	inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
8398	flatbuffers::FlatBufferBuilder &_fbb) {
8399	LessEqualOptionsBuilder builder_(_fbb);
8400	return builder_.Finish();
8401	}
8402
8403	flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8404
8405	struct NegOptionsT : public flatbuffers::NativeTable {
8406	typedef NegOptions TableType;
8407	};
8408
8409	struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8410	typedef NegOptionsT NativeTableType;
8411	typedef NegOptionsBuilder Builder;
8412	bool Verify(flatbuffers::Verifier &verifier) const {
8413	return VerifyTableStart(verifier) &&
8414	verifier.EndTable();
8415	}
8416	NegOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8417	void UnPackTo(NegOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8418	static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8419	};
8420
8421	struct NegOptionsBuilder {
8422	typedef NegOptions Table;
8423	flatbuffers::FlatBufferBuilder &fbb_;
8424	flatbuffers::uoffset_t start_;
8425	explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8426	: fbb_(_fbb) {
8427	start_ = fbb_.StartTable();
8428	}
8429	flatbuffers::Offset<NegOptions> Finish() {
8430	const auto end = fbb_.EndTable(start_);
8431	auto o = flatbuffers::Offset<NegOptions>(end);
8432	return o;
8433	}
8434	};
8435
8436	inline flatbuffers::Offset<NegOptions> CreateNegOptions(
8437	flatbuffers::FlatBufferBuilder &_fbb) {
8438	NegOptionsBuilder builder_(_fbb);
8439	return builder_.Finish();
8440	}
8441
8442	flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8443
8444	struct SelectOptionsT : public flatbuffers::NativeTable {
8445	typedef SelectOptions TableType;
8446	};
8447
8448	struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8449	typedef SelectOptionsT NativeTableType;
8450	typedef SelectOptionsBuilder Builder;
8451	bool Verify(flatbuffers::Verifier &verifier) const {
8452	return VerifyTableStart(verifier) &&
8453	verifier.EndTable();
8454	}
8455	SelectOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8456	void UnPackTo(SelectOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8457	static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8458	};
8459
8460	struct SelectOptionsBuilder {
8461	typedef SelectOptions Table;
8462	flatbuffers::FlatBufferBuilder &fbb_;
8463	flatbuffers::uoffset_t start_;
8464	explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8465	: fbb_(_fbb) {
8466	start_ = fbb_.StartTable();
8467	}
8468	flatbuffers::Offset<SelectOptions> Finish() {
8469	const auto end = fbb_.EndTable(start_);
8470	auto o = flatbuffers::Offset<SelectOptions>(end);
8471	return o;
8472	}
8473	};
8474
8475	inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
8476	flatbuffers::FlatBufferBuilder &_fbb) {
8477	SelectOptionsBuilder builder_(_fbb);
8478	return builder_.Finish();
8479	}
8480
8481	flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8482
8483	struct SliceOptionsT : public flatbuffers::NativeTable {
8484	typedef SliceOptions TableType;
8485	};
8486
8487	struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8488	typedef SliceOptionsT NativeTableType;
8489	typedef SliceOptionsBuilder Builder;
8490	bool Verify(flatbuffers::Verifier &verifier) const {
8491	return VerifyTableStart(verifier) &&
8492	verifier.EndTable();
8493	}
8494	SliceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8495	void UnPackTo(SliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8496	static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8497	};
8498
8499	struct SliceOptionsBuilder {
8500	typedef SliceOptions Table;
8501	flatbuffers::FlatBufferBuilder &fbb_;
8502	flatbuffers::uoffset_t start_;
8503	explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8504	: fbb_(_fbb) {
8505	start_ = fbb_.StartTable();
8506	}
8507	flatbuffers::Offset<SliceOptions> Finish() {
8508	const auto end = fbb_.EndTable(start_);
8509	auto o = flatbuffers::Offset<SliceOptions>(end);
8510	return o;
8511	}
8512	};
8513
8514	inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
8515	flatbuffers::FlatBufferBuilder &_fbb) {
8516	SliceOptionsBuilder builder_(_fbb);
8517	return builder_.Finish();
8518	}
8519
8520	flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8521
8522	struct TransposeConvOptionsT : public flatbuffers::NativeTable {
8523	typedef TransposeConvOptions TableType;
8524	tflite::Padding padding = tflite::Padding_SAME;
8525	int32_t stride_w = `0`;
8526	int32_t stride_h = `0`;
8527	};
8528
8529	struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8530	typedef TransposeConvOptionsT NativeTableType;
8531	typedef TransposeConvOptionsBuilder Builder;
8532	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8533	VT_PADDING = `4`,
8534	VT_STRIDE_W = `6`,
8535	VT_STRIDE_H = `8`
8536	};
8537	tflite::Padding padding() const {
8538	return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, `0`));
8539	}
8540	int32_t stride_w() const {
8541	return GetField<int32_t>(VT_STRIDE_W, `0`);
8542	}
8543	int32_t stride_h() const {
8544	return GetField<int32_t>(VT_STRIDE_H, `0`);
8545	}
8546	bool Verify(flatbuffers::Verifier &verifier) const {
8547	return VerifyTableStart(verifier) &&
8548	VerifyField<int8_t>(verifier, VT_PADDING, `1`) &&
8549	VerifyField<int32_t>(verifier, VT_STRIDE_W, `4`) &&
8550	VerifyField<int32_t>(verifier, VT_STRIDE_H, `4`) &&
8551	verifier.EndTable();
8552	}
8553	TransposeConvOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8554	void UnPackTo(TransposeConvOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8555	static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8556	};
8557
8558	struct TransposeConvOptionsBuilder {
8559	typedef TransposeConvOptions Table;
8560	flatbuffers::FlatBufferBuilder &fbb_;
8561	flatbuffers::uoffset_t start_;
8562	void add_padding(tflite::Padding padding) {
8563	fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), `0`);
8564	}
8565	void add_stride_w(int32_t stride_w) {
8566	fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, `0`);
8567	}
8568	void add_stride_h(int32_t stride_h) {
8569	fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, `0`);
8570	}
8571	explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8572	: fbb_(_fbb) {
8573	start_ = fbb_.StartTable();
8574	}
8575	flatbuffers::Offset<TransposeConvOptions> Finish() {
8576	const auto end = fbb_.EndTable(start_);
8577	auto o = flatbuffers::Offset<TransposeConvOptions>(end);
8578	return o;
8579	}
8580	};
8581
8582	inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
8583	flatbuffers::FlatBufferBuilder &_fbb,
8584	tflite::Padding padding = tflite::Padding_SAME,
8585	int32_t stride_w = `0`,
8586	int32_t stride_h = `0`) {
8587	TransposeConvOptionsBuilder builder_(_fbb);
8588	builder_.add_stride_h(stride_h);
8589	builder_.add_stride_w(stride_w);
8590	builder_.add_padding(padding);
8591	return builder_.Finish();
8592	}
8593
8594	flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8595
8596	struct ExpandDimsOptionsT : public flatbuffers::NativeTable {
8597	typedef ExpandDimsOptions TableType;
8598	};
8599
8600	struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8601	typedef ExpandDimsOptionsT NativeTableType;
8602	typedef ExpandDimsOptionsBuilder Builder;
8603	bool Verify(flatbuffers::Verifier &verifier) const {
8604	return VerifyTableStart(verifier) &&
8605	verifier.EndTable();
8606	}
8607	ExpandDimsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8608	void UnPackTo(ExpandDimsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8609	static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8610	};
8611
8612	struct ExpandDimsOptionsBuilder {
8613	typedef ExpandDimsOptions Table;
8614	flatbuffers::FlatBufferBuilder &fbb_;
8615	flatbuffers::uoffset_t start_;
8616	explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8617	: fbb_(_fbb) {
8618	start_ = fbb_.StartTable();
8619	}
8620	flatbuffers::Offset<ExpandDimsOptions> Finish() {
8621	const auto end = fbb_.EndTable(start_);
8622	auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
8623	return o;
8624	}
8625	};
8626
8627	inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
8628	flatbuffers::FlatBufferBuilder &_fbb) {
8629	ExpandDimsOptionsBuilder builder_(_fbb);
8630	return builder_.Finish();
8631	}
8632
8633	flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8634
8635	struct SparseToDenseOptionsT : public flatbuffers::NativeTable {
8636	typedef SparseToDenseOptions TableType;
8637	bool validate_indices = false;
8638	};
8639
8640	struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8641	typedef SparseToDenseOptionsT NativeTableType;
8642	typedef SparseToDenseOptionsBuilder Builder;
8643	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8644	VT_VALIDATE_INDICES = `4`
8645	};
8646	bool validate_indices() const {
8647	return GetField<uint8_t>(VT_VALIDATE_INDICES, `0`) != `0`;
8648	}
8649	bool Verify(flatbuffers::Verifier &verifier) const {
8650	return VerifyTableStart(verifier) &&
8651	VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES, `1`) &&
8652	verifier.EndTable();
8653	}
8654	SparseToDenseOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8655	void UnPackTo(SparseToDenseOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8656	static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8657	};
8658
8659	struct SparseToDenseOptionsBuilder {
8660	typedef SparseToDenseOptions Table;
8661	flatbuffers::FlatBufferBuilder &fbb_;
8662	flatbuffers::uoffset_t start_;
8663	void add_validate_indices(bool validate_indices) {
8664	fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), `0`);
8665	}
8666	explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8667	: fbb_(_fbb) {
8668	start_ = fbb_.StartTable();
8669	}
8670	flatbuffers::Offset<SparseToDenseOptions> Finish() {
8671	const auto end = fbb_.EndTable(start_);
8672	auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
8673	return o;
8674	}
8675	};
8676
8677	inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
8678	flatbuffers::FlatBufferBuilder &_fbb,
8679	bool validate_indices = false) {
8680	SparseToDenseOptionsBuilder builder_(_fbb);
8681	builder_.add_validate_indices(validate_indices);
8682	return builder_.Finish();
8683	}
8684
8685	flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8686
8687	struct EqualOptionsT : public flatbuffers::NativeTable {
8688	typedef EqualOptions TableType;
8689	};
8690
8691	struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8692	typedef EqualOptionsT NativeTableType;
8693	typedef EqualOptionsBuilder Builder;
8694	bool Verify(flatbuffers::Verifier &verifier) const {
8695	return VerifyTableStart(verifier) &&
8696	verifier.EndTable();
8697	}
8698	EqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8699	void UnPackTo(EqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8700	static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8701	};
8702
8703	struct EqualOptionsBuilder {
8704	typedef EqualOptions Table;
8705	flatbuffers::FlatBufferBuilder &fbb_;
8706	flatbuffers::uoffset_t start_;
8707	explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8708	: fbb_(_fbb) {
8709	start_ = fbb_.StartTable();
8710	}
8711	flatbuffers::Offset<EqualOptions> Finish() {
8712	const auto end = fbb_.EndTable(start_);
8713	auto o = flatbuffers::Offset<EqualOptions>(end);
8714	return o;
8715	}
8716	};
8717
8718	inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
8719	flatbuffers::FlatBufferBuilder &_fbb) {
8720	EqualOptionsBuilder builder_(_fbb);
8721	return builder_.Finish();
8722	}
8723
8724	flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8725
8726	struct NotEqualOptionsT : public flatbuffers::NativeTable {
8727	typedef NotEqualOptions TableType;
8728	};
8729
8730	struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8731	typedef NotEqualOptionsT NativeTableType;
8732	typedef NotEqualOptionsBuilder Builder;
8733	bool Verify(flatbuffers::Verifier &verifier) const {
8734	return VerifyTableStart(verifier) &&
8735	verifier.EndTable();
8736	}
8737	NotEqualOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8738	void UnPackTo(NotEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8739	static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8740	};
8741
8742	struct NotEqualOptionsBuilder {
8743	typedef NotEqualOptions Table;
8744	flatbuffers::FlatBufferBuilder &fbb_;
8745	flatbuffers::uoffset_t start_;
8746	explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8747	: fbb_(_fbb) {
8748	start_ = fbb_.StartTable();
8749	}
8750	flatbuffers::Offset<NotEqualOptions> Finish() {
8751	const auto end = fbb_.EndTable(start_);
8752	auto o = flatbuffers::Offset<NotEqualOptions>(end);
8753	return o;
8754	}
8755	};
8756
8757	inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
8758	flatbuffers::FlatBufferBuilder &_fbb) {
8759	NotEqualOptionsBuilder builder_(_fbb);
8760	return builder_.Finish();
8761	}
8762
8763	flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8764
8765	struct ShapeOptionsT : public flatbuffers::NativeTable {
8766	typedef ShapeOptions TableType;
8767	tflite::TensorType out_type = tflite::TensorType_FLOAT32;
8768	};
8769
8770	struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8771	typedef ShapeOptionsT NativeTableType;
8772	typedef ShapeOptionsBuilder Builder;
8773	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8774	VT_OUT_TYPE = `4`
8775	};
8776	tflite::TensorType out_type() const {
8777	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, `0`));
8778	}
8779	bool Verify(flatbuffers::Verifier &verifier) const {
8780	return VerifyTableStart(verifier) &&
8781	VerifyField<int8_t>(verifier, VT_OUT_TYPE, `1`) &&
8782	verifier.EndTable();
8783	}
8784	ShapeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8785	void UnPackTo(ShapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8786	static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8787	};
8788
8789	struct ShapeOptionsBuilder {
8790	typedef ShapeOptions Table;
8791	flatbuffers::FlatBufferBuilder &fbb_;
8792	flatbuffers::uoffset_t start_;
8793	void add_out_type(tflite::TensorType out_type) {
8794	fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), `0`);
8795	}
8796	explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8797	: fbb_(_fbb) {
8798	start_ = fbb_.StartTable();
8799	}
8800	flatbuffers::Offset<ShapeOptions> Finish() {
8801	const auto end = fbb_.EndTable(start_);
8802	auto o = flatbuffers::Offset<ShapeOptions>(end);
8803	return o;
8804	}
8805	};
8806
8807	inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
8808	flatbuffers::FlatBufferBuilder &_fbb,
8809	tflite::TensorType out_type = tflite::TensorType_FLOAT32) {
8810	ShapeOptionsBuilder builder_(_fbb);
8811	builder_.add_out_type(out_type);
8812	return builder_.Finish();
8813	}
8814
8815	flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8816
8817	struct RankOptionsT : public flatbuffers::NativeTable {
8818	typedef RankOptions TableType;
8819	};
8820
8821	struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8822	typedef RankOptionsT NativeTableType;
8823	typedef RankOptionsBuilder Builder;
8824	bool Verify(flatbuffers::Verifier &verifier) const {
8825	return VerifyTableStart(verifier) &&
8826	verifier.EndTable();
8827	}
8828	RankOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8829	void UnPackTo(RankOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8830	static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8831	};
8832
8833	struct RankOptionsBuilder {
8834	typedef RankOptions Table;
8835	flatbuffers::FlatBufferBuilder &fbb_;
8836	flatbuffers::uoffset_t start_;
8837	explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8838	: fbb_(_fbb) {
8839	start_ = fbb_.StartTable();
8840	}
8841	flatbuffers::Offset<RankOptions> Finish() {
8842	const auto end = fbb_.EndTable(start_);
8843	auto o = flatbuffers::Offset<RankOptions>(end);
8844	return o;
8845	}
8846	};
8847
8848	inline flatbuffers::Offset<RankOptions> CreateRankOptions(
8849	flatbuffers::FlatBufferBuilder &_fbb) {
8850	RankOptionsBuilder builder_(_fbb);
8851	return builder_.Finish();
8852	}
8853
8854	flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8855
8856	struct PowOptionsT : public flatbuffers::NativeTable {
8857	typedef PowOptions TableType;
8858	};
8859
8860	struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8861	typedef PowOptionsT NativeTableType;
8862	typedef PowOptionsBuilder Builder;
8863	bool Verify(flatbuffers::Verifier &verifier) const {
8864	return VerifyTableStart(verifier) &&
8865	verifier.EndTable();
8866	}
8867	PowOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8868	void UnPackTo(PowOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8869	static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8870	};
8871
8872	struct PowOptionsBuilder {
8873	typedef PowOptions Table;
8874	flatbuffers::FlatBufferBuilder &fbb_;
8875	flatbuffers::uoffset_t start_;
8876	explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8877	: fbb_(_fbb) {
8878	start_ = fbb_.StartTable();
8879	}
8880	flatbuffers::Offset<PowOptions> Finish() {
8881	const auto end = fbb_.EndTable(start_);
8882	auto o = flatbuffers::Offset<PowOptions>(end);
8883	return o;
8884	}
8885	};
8886
8887	inline flatbuffers::Offset<PowOptions> CreatePowOptions(
8888	flatbuffers::FlatBufferBuilder &_fbb) {
8889	PowOptionsBuilder builder_(_fbb);
8890	return builder_.Finish();
8891	}
8892
8893	flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8894
8895	struct FakeQuantOptionsT : public flatbuffers::NativeTable {
8896	typedef FakeQuantOptions TableType;
8897	float min = `0.0f`;
8898	float max = `0.0f`;
8899	int32_t num_bits = `0`;
8900	bool narrow_range = false;
8901	};
8902
8903	struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8904	typedef FakeQuantOptionsT NativeTableType;
8905	typedef FakeQuantOptionsBuilder Builder;
8906	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8907	VT_MIN = `4`,
8908	VT_MAX = `6`,
8909	VT_NUM_BITS = `8`,
8910	VT_NARROW_RANGE = `10`
8911	};
8912	float min() const {
8913	return GetField<float>(VT_MIN, `0.0f`);
8914	}
8915	float max() const {
8916	return GetField<float>(VT_MAX, `0.0f`);
8917	}
8918	int32_t num_bits() const {
8919	return GetField<int32_t>(VT_NUM_BITS, `0`);
8920	}
8921	bool narrow_range() const {
8922	return GetField<uint8_t>(VT_NARROW_RANGE, `0`) != `0`;
8923	}
8924	bool Verify(flatbuffers::Verifier &verifier) const {
8925	return VerifyTableStart(verifier) &&
8926	VerifyField<float>(verifier, VT_MIN, `4`) &&
8927	VerifyField<float>(verifier, VT_MAX, `4`) &&
8928	VerifyField<int32_t>(verifier, VT_NUM_BITS, `4`) &&
8929	VerifyField<uint8_t>(verifier, VT_NARROW_RANGE, `1`) &&
8930	verifier.EndTable();
8931	}
8932	FakeQuantOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8933	void UnPackTo(FakeQuantOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
8934	static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
8935	};
8936
8937	struct FakeQuantOptionsBuilder {
8938	typedef FakeQuantOptions Table;
8939	flatbuffers::FlatBufferBuilder &fbb_;
8940	flatbuffers::uoffset_t start_;
8941	void add_min(float min) {
8942	fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, `0.0f`);
8943	}
8944	void add_max(float max) {
8945	fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, `0.0f`);
8946	}
8947	void add_num_bits(int32_t num_bits) {
8948	fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, `0`);
8949	}
8950	void add_narrow_range(bool narrow_range) {
8951	fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), `0`);
8952	}
8953	explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
8954	: fbb_(_fbb) {
8955	start_ = fbb_.StartTable();
8956	}
8957	flatbuffers::Offset<FakeQuantOptions> Finish() {
8958	const auto end = fbb_.EndTable(start_);
8959	auto o = flatbuffers::Offset<FakeQuantOptions>(end);
8960	return o;
8961	}
8962	};
8963
8964	inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
8965	flatbuffers::FlatBufferBuilder &_fbb,
8966	float min = `0.0f`,
8967	float max = `0.0f`,
8968	int32_t num_bits = `0`,
8969	bool narrow_range = false) {
8970	FakeQuantOptionsBuilder builder_(_fbb);
8971	builder_.add_num_bits(num_bits);
8972	builder_.add_max(max);
8973	builder_.add_min(min);
8974	builder_.add_narrow_range(narrow_range);
8975	return builder_.Finish();
8976	}
8977
8978	flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
8979
8980	struct PackOptionsT : public flatbuffers::NativeTable {
8981	typedef PackOptions TableType;
8982	int32_t values_count = `0`;
8983	int32_t axis = `0`;
8984	};
8985
8986	struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8987	typedef PackOptionsT NativeTableType;
8988	typedef PackOptionsBuilder Builder;
8989	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8990	VT_VALUES_COUNT = `4`,
8991	VT_AXIS = `6`
8992	};
8993	int32_t values_count() const {
8994	return GetField<int32_t>(VT_VALUES_COUNT, `0`);
8995	}
8996	int32_t axis() const {
8997	return GetField<int32_t>(VT_AXIS, `0`);
8998	}
8999	bool Verify(flatbuffers::Verifier &verifier) const {
9000	return VerifyTableStart(verifier) &&
9001	VerifyField<int32_t>(verifier, VT_VALUES_COUNT, `4`) &&
9002	VerifyField<int32_t>(verifier, VT_AXIS, `4`) &&
9003	verifier.EndTable();
9004	}
9005	PackOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9006	void UnPackTo(PackOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9007	static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9008	};
9009
9010	struct PackOptionsBuilder {
9011	typedef PackOptions Table;
9012	flatbuffers::FlatBufferBuilder &fbb_;
9013	flatbuffers::uoffset_t start_;
9014	void add_values_count(int32_t values_count) {
9015	fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, `0`);
9016	}
9017	void add_axis(int32_t axis) {
9018	fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, `0`);
9019	}
9020	explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9021	: fbb_(_fbb) {
9022	start_ = fbb_.StartTable();
9023	}
9024	flatbuffers::Offset<PackOptions> Finish() {
9025	const auto end = fbb_.EndTable(start_);
9026	auto o = flatbuffers::Offset<PackOptions>(end);
9027	return o;
9028	}
9029	};
9030
9031	inline flatbuffers::Offset<PackOptions> CreatePackOptions(
9032	flatbuffers::FlatBufferBuilder &_fbb,
9033	int32_t values_count = `0`,
9034	int32_t axis = `0`) {
9035	PackOptionsBuilder builder_(_fbb);
9036	builder_.add_axis(axis);
9037	builder_.add_values_count(values_count);
9038	return builder_.Finish();
9039	}
9040
9041	flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9042
9043	struct LogicalOrOptionsT : public flatbuffers::NativeTable {
9044	typedef LogicalOrOptions TableType;
9045	};
9046
9047	struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9048	typedef LogicalOrOptionsT NativeTableType;
9049	typedef LogicalOrOptionsBuilder Builder;
9050	bool Verify(flatbuffers::Verifier &verifier) const {
9051	return VerifyTableStart(verifier) &&
9052	verifier.EndTable();
9053	}
9054	LogicalOrOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9055	void UnPackTo(LogicalOrOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9056	static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9057	};
9058
9059	struct LogicalOrOptionsBuilder {
9060	typedef LogicalOrOptions Table;
9061	flatbuffers::FlatBufferBuilder &fbb_;
9062	flatbuffers::uoffset_t start_;
9063	explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9064	: fbb_(_fbb) {
9065	start_ = fbb_.StartTable();
9066	}
9067	flatbuffers::Offset<LogicalOrOptions> Finish() {
9068	const auto end = fbb_.EndTable(start_);
9069	auto o = flatbuffers::Offset<LogicalOrOptions>(end);
9070	return o;
9071	}
9072	};
9073
9074	inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
9075	flatbuffers::FlatBufferBuilder &_fbb) {
9076	LogicalOrOptionsBuilder builder_(_fbb);
9077	return builder_.Finish();
9078	}
9079
9080	flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9081
9082	struct OneHotOptionsT : public flatbuffers::NativeTable {
9083	typedef OneHotOptions TableType;
9084	int32_t axis = `0`;
9085	};
9086
9087	struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9088	typedef OneHotOptionsT NativeTableType;
9089	typedef OneHotOptionsBuilder Builder;
9090	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9091	VT_AXIS = `4`
9092	};
9093	int32_t axis() const {
9094	return GetField<int32_t>(VT_AXIS, `0`);
9095	}
9096	bool Verify(flatbuffers::Verifier &verifier) const {
9097	return VerifyTableStart(verifier) &&
9098	VerifyField<int32_t>(verifier, VT_AXIS, `4`) &&
9099	verifier.EndTable();
9100	}
9101	OneHotOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9102	void UnPackTo(OneHotOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9103	static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9104	};
9105
9106	struct OneHotOptionsBuilder {
9107	typedef OneHotOptions Table;
9108	flatbuffers::FlatBufferBuilder &fbb_;
9109	flatbuffers::uoffset_t start_;
9110	void add_axis(int32_t axis) {
9111	fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, `0`);
9112	}
9113	explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9114	: fbb_(_fbb) {
9115	start_ = fbb_.StartTable();
9116	}
9117	flatbuffers::Offset<OneHotOptions> Finish() {
9118	const auto end = fbb_.EndTable(start_);
9119	auto o = flatbuffers::Offset<OneHotOptions>(end);
9120	return o;
9121	}
9122	};
9123
9124	inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
9125	flatbuffers::FlatBufferBuilder &_fbb,
9126	int32_t axis = `0`) {
9127	OneHotOptionsBuilder builder_(_fbb);
9128	builder_.add_axis(axis);
9129	return builder_.Finish();
9130	}
9131
9132	flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9133
9134	struct AbsOptionsT : public flatbuffers::NativeTable {
9135	typedef AbsOptions TableType;
9136	};
9137
9138	struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9139	typedef AbsOptionsT NativeTableType;
9140	typedef AbsOptionsBuilder Builder;
9141	bool Verify(flatbuffers::Verifier &verifier) const {
9142	return VerifyTableStart(verifier) &&
9143	verifier.EndTable();
9144	}
9145	AbsOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9146	void UnPackTo(AbsOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9147	static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9148	};
9149
9150	struct AbsOptionsBuilder {
9151	typedef AbsOptions Table;
9152	flatbuffers::FlatBufferBuilder &fbb_;
9153	flatbuffers::uoffset_t start_;
9154	explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9155	: fbb_(_fbb) {
9156	start_ = fbb_.StartTable();
9157	}
9158	flatbuffers::Offset<AbsOptions> Finish() {
9159	const auto end = fbb_.EndTable(start_);
9160	auto o = flatbuffers::Offset<AbsOptions>(end);
9161	return o;
9162	}
9163	};
9164
9165	inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
9166	flatbuffers::FlatBufferBuilder &_fbb) {
9167	AbsOptionsBuilder builder_(_fbb);
9168	return builder_.Finish();
9169	}
9170
9171	flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9172
9173	struct HardSwishOptionsT : public flatbuffers::NativeTable {
9174	typedef HardSwishOptions TableType;
9175	};
9176
9177	struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9178	typedef HardSwishOptionsT NativeTableType;
9179	typedef HardSwishOptionsBuilder Builder;
9180	bool Verify(flatbuffers::Verifier &verifier) const {
9181	return VerifyTableStart(verifier) &&
9182	verifier.EndTable();
9183	}
9184	HardSwishOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9185	void UnPackTo(HardSwishOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9186	static flatbuffers::Offset<HardSwishOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9187	};
9188
9189	struct HardSwishOptionsBuilder {
9190	typedef HardSwishOptions Table;
9191	flatbuffers::FlatBufferBuilder &fbb_;
9192	flatbuffers::uoffset_t start_;
9193	explicit HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9194	: fbb_(_fbb) {
9195	start_ = fbb_.StartTable();
9196	}
9197	flatbuffers::Offset<HardSwishOptions> Finish() {
9198	const auto end = fbb_.EndTable(start_);
9199	auto o = flatbuffers::Offset<HardSwishOptions>(end);
9200	return o;
9201	}
9202	};
9203
9204	inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
9205	flatbuffers::FlatBufferBuilder &_fbb) {
9206	HardSwishOptionsBuilder builder_(_fbb);
9207	return builder_.Finish();
9208	}
9209
9210	flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9211
9212	struct LogicalAndOptionsT : public flatbuffers::NativeTable {
9213	typedef LogicalAndOptions TableType;
9214	};
9215
9216	struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9217	typedef LogicalAndOptionsT NativeTableType;
9218	typedef LogicalAndOptionsBuilder Builder;
9219	bool Verify(flatbuffers::Verifier &verifier) const {
9220	return VerifyTableStart(verifier) &&
9221	verifier.EndTable();
9222	}
9223	LogicalAndOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9224	void UnPackTo(LogicalAndOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9225	static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9226	};
9227
9228	struct LogicalAndOptionsBuilder {
9229	typedef LogicalAndOptions Table;
9230	flatbuffers::FlatBufferBuilder &fbb_;
9231	flatbuffers::uoffset_t start_;
9232	explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9233	: fbb_(_fbb) {
9234	start_ = fbb_.StartTable();
9235	}
9236	flatbuffers::Offset<LogicalAndOptions> Finish() {
9237	const auto end = fbb_.EndTable(start_);
9238	auto o = flatbuffers::Offset<LogicalAndOptions>(end);
9239	return o;
9240	}
9241	};
9242
9243	inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
9244	flatbuffers::FlatBufferBuilder &_fbb) {
9245	LogicalAndOptionsBuilder builder_(_fbb);
9246	return builder_.Finish();
9247	}
9248
9249	flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9250
9251	struct LogicalNotOptionsT : public flatbuffers::NativeTable {
9252	typedef LogicalNotOptions TableType;
9253	};
9254
9255	struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9256	typedef LogicalNotOptionsT NativeTableType;
9257	typedef LogicalNotOptionsBuilder Builder;
9258	bool Verify(flatbuffers::Verifier &verifier) const {
9259	return VerifyTableStart(verifier) &&
9260	verifier.EndTable();
9261	}
9262	LogicalNotOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9263	void UnPackTo(LogicalNotOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9264	static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9265	};
9266
9267	struct LogicalNotOptionsBuilder {
9268	typedef LogicalNotOptions Table;
9269	flatbuffers::FlatBufferBuilder &fbb_;
9270	flatbuffers::uoffset_t start_;
9271	explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9272	: fbb_(_fbb) {
9273	start_ = fbb_.StartTable();
9274	}
9275	flatbuffers::Offset<LogicalNotOptions> Finish() {
9276	const auto end = fbb_.EndTable(start_);
9277	auto o = flatbuffers::Offset<LogicalNotOptions>(end);
9278	return o;
9279	}
9280	};
9281
9282	inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
9283	flatbuffers::FlatBufferBuilder &_fbb) {
9284	LogicalNotOptionsBuilder builder_(_fbb);
9285	return builder_.Finish();
9286	}
9287
9288	flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9289
9290	struct UnpackOptionsT : public flatbuffers::NativeTable {
9291	typedef UnpackOptions TableType;
9292	int32_t num = `0`;
9293	int32_t axis = `0`;
9294	};
9295
9296	struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9297	typedef UnpackOptionsT NativeTableType;
9298	typedef UnpackOptionsBuilder Builder;
9299	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9300	VT_NUM = `4`,
9301	VT_AXIS = `6`
9302	};
9303	int32_t num() const {
9304	return GetField<int32_t>(VT_NUM, `0`);
9305	}
9306	int32_t axis() const {
9307	return GetField<int32_t>(VT_AXIS, `0`);
9308	}
9309	bool Verify(flatbuffers::Verifier &verifier) const {
9310	return VerifyTableStart(verifier) &&
9311	VerifyField<int32_t>(verifier, VT_NUM, `4`) &&
9312	VerifyField<int32_t>(verifier, VT_AXIS, `4`) &&
9313	verifier.EndTable();
9314	}
9315	UnpackOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9316	void UnPackTo(UnpackOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9317	static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9318	};
9319
9320	struct UnpackOptionsBuilder {
9321	typedef UnpackOptions Table;
9322	flatbuffers::FlatBufferBuilder &fbb_;
9323	flatbuffers::uoffset_t start_;
9324	void add_num(int32_t num) {
9325	fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, `0`);
9326	}
9327	void add_axis(int32_t axis) {
9328	fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, `0`);
9329	}
9330	explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9331	: fbb_(_fbb) {
9332	start_ = fbb_.StartTable();
9333	}
9334	flatbuffers::Offset<UnpackOptions> Finish() {
9335	const auto end = fbb_.EndTable(start_);
9336	auto o = flatbuffers::Offset<UnpackOptions>(end);
9337	return o;
9338	}
9339	};
9340
9341	inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
9342	flatbuffers::FlatBufferBuilder &_fbb,
9343	int32_t num = `0`,
9344	int32_t axis = `0`) {
9345	UnpackOptionsBuilder builder_(_fbb);
9346	builder_.add_axis(axis);
9347	builder_.add_num(num);
9348	return builder_.Finish();
9349	}
9350
9351	flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9352
9353	struct FloorDivOptionsT : public flatbuffers::NativeTable {
9354	typedef FloorDivOptions TableType;
9355	};
9356
9357	struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9358	typedef FloorDivOptionsT NativeTableType;
9359	typedef FloorDivOptionsBuilder Builder;
9360	bool Verify(flatbuffers::Verifier &verifier) const {
9361	return VerifyTableStart(verifier) &&
9362	verifier.EndTable();
9363	}
9364	FloorDivOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9365	void UnPackTo(FloorDivOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9366	static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9367	};
9368
9369	struct FloorDivOptionsBuilder {
9370	typedef FloorDivOptions Table;
9371	flatbuffers::FlatBufferBuilder &fbb_;
9372	flatbuffers::uoffset_t start_;
9373	explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9374	: fbb_(_fbb) {
9375	start_ = fbb_.StartTable();
9376	}
9377	flatbuffers::Offset<FloorDivOptions> Finish() {
9378	const auto end = fbb_.EndTable(start_);
9379	auto o = flatbuffers::Offset<FloorDivOptions>(end);
9380	return o;
9381	}
9382	};
9383
9384	inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
9385	flatbuffers::FlatBufferBuilder &_fbb) {
9386	FloorDivOptionsBuilder builder_(_fbb);
9387	return builder_.Finish();
9388	}
9389
9390	flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9391
9392	struct SquareOptionsT : public flatbuffers::NativeTable {
9393	typedef SquareOptions TableType;
9394	};
9395
9396	struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9397	typedef SquareOptionsT NativeTableType;
9398	typedef SquareOptionsBuilder Builder;
9399	bool Verify(flatbuffers::Verifier &verifier) const {
9400	return VerifyTableStart(verifier) &&
9401	verifier.EndTable();
9402	}
9403	SquareOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9404	void UnPackTo(SquareOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9405	static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9406	};
9407
9408	struct SquareOptionsBuilder {
9409	typedef SquareOptions Table;
9410	flatbuffers::FlatBufferBuilder &fbb_;
9411	flatbuffers::uoffset_t start_;
9412	explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9413	: fbb_(_fbb) {
9414	start_ = fbb_.StartTable();
9415	}
9416	flatbuffers::Offset<SquareOptions> Finish() {
9417	const auto end = fbb_.EndTable(start_);
9418	auto o = flatbuffers::Offset<SquareOptions>(end);
9419	return o;
9420	}
9421	};
9422
9423	inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
9424	flatbuffers::FlatBufferBuilder &_fbb) {
9425	SquareOptionsBuilder builder_(_fbb);
9426	return builder_.Finish();
9427	}
9428
9429	flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9430
9431	struct ZerosLikeOptionsT : public flatbuffers::NativeTable {
9432	typedef ZerosLikeOptions TableType;
9433	};
9434
9435	struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9436	typedef ZerosLikeOptionsT NativeTableType;
9437	typedef ZerosLikeOptionsBuilder Builder;
9438	bool Verify(flatbuffers::Verifier &verifier) const {
9439	return VerifyTableStart(verifier) &&
9440	verifier.EndTable();
9441	}
9442	ZerosLikeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9443	void UnPackTo(ZerosLikeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9444	static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9445	};
9446
9447	struct ZerosLikeOptionsBuilder {
9448	typedef ZerosLikeOptions Table;
9449	flatbuffers::FlatBufferBuilder &fbb_;
9450	flatbuffers::uoffset_t start_;
9451	explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9452	: fbb_(_fbb) {
9453	start_ = fbb_.StartTable();
9454	}
9455	flatbuffers::Offset<ZerosLikeOptions> Finish() {
9456	const auto end = fbb_.EndTable(start_);
9457	auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
9458	return o;
9459	}
9460	};
9461
9462	inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
9463	flatbuffers::FlatBufferBuilder &_fbb) {
9464	ZerosLikeOptionsBuilder builder_(_fbb);
9465	return builder_.Finish();
9466	}
9467
9468	flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9469
9470	struct FillOptionsT : public flatbuffers::NativeTable {
9471	typedef FillOptions TableType;
9472	};
9473
9474	struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9475	typedef FillOptionsT NativeTableType;
9476	typedef FillOptionsBuilder Builder;
9477	bool Verify(flatbuffers::Verifier &verifier) const {
9478	return VerifyTableStart(verifier) &&
9479	verifier.EndTable();
9480	}
9481	FillOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9482	void UnPackTo(FillOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9483	static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9484	};
9485
9486	struct FillOptionsBuilder {
9487	typedef FillOptions Table;
9488	flatbuffers::FlatBufferBuilder &fbb_;
9489	flatbuffers::uoffset_t start_;
9490	explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9491	: fbb_(_fbb) {
9492	start_ = fbb_.StartTable();
9493	}
9494	flatbuffers::Offset<FillOptions> Finish() {
9495	const auto end = fbb_.EndTable(start_);
9496	auto o = flatbuffers::Offset<FillOptions>(end);
9497	return o;
9498	}
9499	};
9500
9501	inline flatbuffers::Offset<FillOptions> CreateFillOptions(
9502	flatbuffers::FlatBufferBuilder &_fbb) {
9503	FillOptionsBuilder builder_(_fbb);
9504	return builder_.Finish();
9505	}
9506
9507	flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9508
9509	struct FloorModOptionsT : public flatbuffers::NativeTable {
9510	typedef FloorModOptions TableType;
9511	};
9512
9513	struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9514	typedef FloorModOptionsT NativeTableType;
9515	typedef FloorModOptionsBuilder Builder;
9516	bool Verify(flatbuffers::Verifier &verifier) const {
9517	return VerifyTableStart(verifier) &&
9518	verifier.EndTable();
9519	}
9520	FloorModOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9521	void UnPackTo(FloorModOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9522	static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9523	};
9524
9525	struct FloorModOptionsBuilder {
9526	typedef FloorModOptions Table;
9527	flatbuffers::FlatBufferBuilder &fbb_;
9528	flatbuffers::uoffset_t start_;
9529	explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9530	: fbb_(_fbb) {
9531	start_ = fbb_.StartTable();
9532	}
9533	flatbuffers::Offset<FloorModOptions> Finish() {
9534	const auto end = fbb_.EndTable(start_);
9535	auto o = flatbuffers::Offset<FloorModOptions>(end);
9536	return o;
9537	}
9538	};
9539
9540	inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
9541	flatbuffers::FlatBufferBuilder &_fbb) {
9542	FloorModOptionsBuilder builder_(_fbb);
9543	return builder_.Finish();
9544	}
9545
9546	flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9547
9548	struct RangeOptionsT : public flatbuffers::NativeTable {
9549	typedef RangeOptions TableType;
9550	};
9551
9552	struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9553	typedef RangeOptionsT NativeTableType;
9554	typedef RangeOptionsBuilder Builder;
9555	bool Verify(flatbuffers::Verifier &verifier) const {
9556	return VerifyTableStart(verifier) &&
9557	verifier.EndTable();
9558	}
9559	RangeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9560	void UnPackTo(RangeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9561	static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9562	};
9563
9564	struct RangeOptionsBuilder {
9565	typedef RangeOptions Table;
9566	flatbuffers::FlatBufferBuilder &fbb_;
9567	flatbuffers::uoffset_t start_;
9568	explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9569	: fbb_(_fbb) {
9570	start_ = fbb_.StartTable();
9571	}
9572	flatbuffers::Offset<RangeOptions> Finish() {
9573	const auto end = fbb_.EndTable(start_);
9574	auto o = flatbuffers::Offset<RangeOptions>(end);
9575	return o;
9576	}
9577	};
9578
9579	inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
9580	flatbuffers::FlatBufferBuilder &_fbb) {
9581	RangeOptionsBuilder builder_(_fbb);
9582	return builder_.Finish();
9583	}
9584
9585	flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9586
9587	struct LeakyReluOptionsT : public flatbuffers::NativeTable {
9588	typedef LeakyReluOptions TableType;
9589	float alpha = `0.0f`;
9590	};
9591
9592	struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9593	typedef LeakyReluOptionsT NativeTableType;
9594	typedef LeakyReluOptionsBuilder Builder;
9595	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9596	VT_ALPHA = `4`
9597	};
9598	float alpha() const {
9599	return GetField<float>(VT_ALPHA, `0.0f`);
9600	}
9601	bool Verify(flatbuffers::Verifier &verifier) const {
9602	return VerifyTableStart(verifier) &&
9603	VerifyField<float>(verifier, VT_ALPHA, `4`) &&
9604	verifier.EndTable();
9605	}
9606	LeakyReluOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9607	void UnPackTo(LeakyReluOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9608	static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9609	};
9610
9611	struct LeakyReluOptionsBuilder {
9612	typedef LeakyReluOptions Table;
9613	flatbuffers::FlatBufferBuilder &fbb_;
9614	flatbuffers::uoffset_t start_;
9615	void add_alpha(float alpha) {
9616	fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, `0.0f`);
9617	}
9618	explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9619	: fbb_(_fbb) {
9620	start_ = fbb_.StartTable();
9621	}
9622	flatbuffers::Offset<LeakyReluOptions> Finish() {
9623	const auto end = fbb_.EndTable(start_);
9624	auto o = flatbuffers::Offset<LeakyReluOptions>(end);
9625	return o;
9626	}
9627	};
9628
9629	inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
9630	flatbuffers::FlatBufferBuilder &_fbb,
9631	float alpha = `0.0f`) {
9632	LeakyReluOptionsBuilder builder_(_fbb);
9633	builder_.add_alpha(alpha);
9634	return builder_.Finish();
9635	}
9636
9637	flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9638
9639	struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable {
9640	typedef SquaredDifferenceOptions TableType;
9641	};
9642
9643	struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9644	typedef SquaredDifferenceOptionsT NativeTableType;
9645	typedef SquaredDifferenceOptionsBuilder Builder;
9646	bool Verify(flatbuffers::Verifier &verifier) const {
9647	return VerifyTableStart(verifier) &&
9648	verifier.EndTable();
9649	}
9650	SquaredDifferenceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9651	void UnPackTo(SquaredDifferenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9652	static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9653	};
9654
9655	struct SquaredDifferenceOptionsBuilder {
9656	typedef SquaredDifferenceOptions Table;
9657	flatbuffers::FlatBufferBuilder &fbb_;
9658	flatbuffers::uoffset_t start_;
9659	explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9660	: fbb_(_fbb) {
9661	start_ = fbb_.StartTable();
9662	}
9663	flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
9664	const auto end = fbb_.EndTable(start_);
9665	auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
9666	return o;
9667	}
9668	};
9669
9670	inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
9671	flatbuffers::FlatBufferBuilder &_fbb) {
9672	SquaredDifferenceOptionsBuilder builder_(_fbb);
9673	return builder_.Finish();
9674	}
9675
9676	flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9677
9678	struct MirrorPadOptionsT : public flatbuffers::NativeTable {
9679	typedef MirrorPadOptions TableType;
9680	tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT;
9681	};
9682
9683	struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9684	typedef MirrorPadOptionsT NativeTableType;
9685	typedef MirrorPadOptionsBuilder Builder;
9686	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9687	VT_MODE = `4`
9688	};
9689	tflite::MirrorPadMode mode() const {
9690	return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, `0`));
9691	}
9692	bool Verify(flatbuffers::Verifier &verifier) const {
9693	return VerifyTableStart(verifier) &&
9694	VerifyField<int8_t>(verifier, VT_MODE, `1`) &&
9695	verifier.EndTable();
9696	}
9697	MirrorPadOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9698	void UnPackTo(MirrorPadOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9699	static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9700	};
9701
9702	struct MirrorPadOptionsBuilder {
9703	typedef MirrorPadOptions Table;
9704	flatbuffers::FlatBufferBuilder &fbb_;
9705	flatbuffers::uoffset_t start_;
9706	void add_mode(tflite::MirrorPadMode mode) {
9707	fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), `0`);
9708	}
9709	explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9710	: fbb_(_fbb) {
9711	start_ = fbb_.StartTable();
9712	}
9713	flatbuffers::Offset<MirrorPadOptions> Finish() {
9714	const auto end = fbb_.EndTable(start_);
9715	auto o = flatbuffers::Offset<MirrorPadOptions>(end);
9716	return o;
9717	}
9718	};
9719
9720	inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
9721	flatbuffers::FlatBufferBuilder &_fbb,
9722	tflite::MirrorPadMode mode = tflite::MirrorPadMode_REFLECT) {
9723	MirrorPadOptionsBuilder builder_(_fbb);
9724	builder_.add_mode(mode);
9725	return builder_.Finish();
9726	}
9727
9728	flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9729
9730	struct UniqueOptionsT : public flatbuffers::NativeTable {
9731	typedef UniqueOptions TableType;
9732	tflite::TensorType idx_out_type = tflite::TensorType_INT32;
9733	};
9734
9735	struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9736	typedef UniqueOptionsT NativeTableType;
9737	typedef UniqueOptionsBuilder Builder;
9738	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9739	VT_IDX_OUT_TYPE = `4`
9740	};
9741	tflite::TensorType idx_out_type() const {
9742	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, `2`));
9743	}
9744	bool Verify(flatbuffers::Verifier &verifier) const {
9745	return VerifyTableStart(verifier) &&
9746	VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE, `1`) &&
9747	verifier.EndTable();
9748	}
9749	UniqueOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9750	void UnPackTo(UniqueOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9751	static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9752	};
9753
9754	struct UniqueOptionsBuilder {
9755	typedef UniqueOptions Table;
9756	flatbuffers::FlatBufferBuilder &fbb_;
9757	flatbuffers::uoffset_t start_;
9758	void add_idx_out_type(tflite::TensorType idx_out_type) {
9759	fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), `2`);
9760	}
9761	explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9762	: fbb_(_fbb) {
9763	start_ = fbb_.StartTable();
9764	}
9765	flatbuffers::Offset<UniqueOptions> Finish() {
9766	const auto end = fbb_.EndTable(start_);
9767	auto o = flatbuffers::Offset<UniqueOptions>(end);
9768	return o;
9769	}
9770	};
9771
9772	inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
9773	flatbuffers::FlatBufferBuilder &_fbb,
9774	tflite::TensorType idx_out_type = tflite::TensorType_INT32) {
9775	UniqueOptionsBuilder builder_(_fbb);
9776	builder_.add_idx_out_type(idx_out_type);
9777	return builder_.Finish();
9778	}
9779
9780	flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9781
9782	struct ReverseV2OptionsT : public flatbuffers::NativeTable {
9783	typedef ReverseV2Options TableType;
9784	};
9785
9786	struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9787	typedef ReverseV2OptionsT NativeTableType;
9788	typedef ReverseV2OptionsBuilder Builder;
9789	bool Verify(flatbuffers::Verifier &verifier) const {
9790	return VerifyTableStart(verifier) &&
9791	verifier.EndTable();
9792	}
9793	ReverseV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9794	void UnPackTo(ReverseV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9795	static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9796	};
9797
9798	struct ReverseV2OptionsBuilder {
9799	typedef ReverseV2Options Table;
9800	flatbuffers::FlatBufferBuilder &fbb_;
9801	flatbuffers::uoffset_t start_;
9802	explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9803	: fbb_(_fbb) {
9804	start_ = fbb_.StartTable();
9805	}
9806	flatbuffers::Offset<ReverseV2Options> Finish() {
9807	const auto end = fbb_.EndTable(start_);
9808	auto o = flatbuffers::Offset<ReverseV2Options>(end);
9809	return o;
9810	}
9811	};
9812
9813	inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
9814	flatbuffers::FlatBufferBuilder &_fbb) {
9815	ReverseV2OptionsBuilder builder_(_fbb);
9816	return builder_.Finish();
9817	}
9818
9819	flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9820
9821	struct AddNOptionsT : public flatbuffers::NativeTable {
9822	typedef AddNOptions TableType;
9823	};
9824
9825	struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9826	typedef AddNOptionsT NativeTableType;
9827	typedef AddNOptionsBuilder Builder;
9828	bool Verify(flatbuffers::Verifier &verifier) const {
9829	return VerifyTableStart(verifier) &&
9830	verifier.EndTable();
9831	}
9832	AddNOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9833	void UnPackTo(AddNOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9834	static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9835	};
9836
9837	struct AddNOptionsBuilder {
9838	typedef AddNOptions Table;
9839	flatbuffers::FlatBufferBuilder &fbb_;
9840	flatbuffers::uoffset_t start_;
9841	explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9842	: fbb_(_fbb) {
9843	start_ = fbb_.StartTable();
9844	}
9845	flatbuffers::Offset<AddNOptions> Finish() {
9846	const auto end = fbb_.EndTable(start_);
9847	auto o = flatbuffers::Offset<AddNOptions>(end);
9848	return o;
9849	}
9850	};
9851
9852	inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
9853	flatbuffers::FlatBufferBuilder &_fbb) {
9854	AddNOptionsBuilder builder_(_fbb);
9855	return builder_.Finish();
9856	}
9857
9858	flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9859
9860	struct GatherNdOptionsT : public flatbuffers::NativeTable {
9861	typedef GatherNdOptions TableType;
9862	};
9863
9864	struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9865	typedef GatherNdOptionsT NativeTableType;
9866	typedef GatherNdOptionsBuilder Builder;
9867	bool Verify(flatbuffers::Verifier &verifier) const {
9868	return VerifyTableStart(verifier) &&
9869	verifier.EndTable();
9870	}
9871	GatherNdOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9872	void UnPackTo(GatherNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9873	static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9874	};
9875
9876	struct GatherNdOptionsBuilder {
9877	typedef GatherNdOptions Table;
9878	flatbuffers::FlatBufferBuilder &fbb_;
9879	flatbuffers::uoffset_t start_;
9880	explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9881	: fbb_(_fbb) {
9882	start_ = fbb_.StartTable();
9883	}
9884	flatbuffers::Offset<GatherNdOptions> Finish() {
9885	const auto end = fbb_.EndTable(start_);
9886	auto o = flatbuffers::Offset<GatherNdOptions>(end);
9887	return o;
9888	}
9889	};
9890
9891	inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
9892	flatbuffers::FlatBufferBuilder &_fbb) {
9893	GatherNdOptionsBuilder builder_(_fbb);
9894	return builder_.Finish();
9895	}
9896
9897	flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9898
9899	struct WhereOptionsT : public flatbuffers::NativeTable {
9900	typedef WhereOptions TableType;
9901	};
9902
9903	struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9904	typedef WhereOptionsT NativeTableType;
9905	typedef WhereOptionsBuilder Builder;
9906	bool Verify(flatbuffers::Verifier &verifier) const {
9907	return VerifyTableStart(verifier) &&
9908	verifier.EndTable();
9909	}
9910	WhereOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9911	void UnPackTo(WhereOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9912	static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9913	};
9914
9915	struct WhereOptionsBuilder {
9916	typedef WhereOptions Table;
9917	flatbuffers::FlatBufferBuilder &fbb_;
9918	flatbuffers::uoffset_t start_;
9919	explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9920	: fbb_(_fbb) {
9921	start_ = fbb_.StartTable();
9922	}
9923	flatbuffers::Offset<WhereOptions> Finish() {
9924	const auto end = fbb_.EndTable(start_);
9925	auto o = flatbuffers::Offset<WhereOptions>(end);
9926	return o;
9927	}
9928	};
9929
9930	inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
9931	flatbuffers::FlatBufferBuilder &_fbb) {
9932	WhereOptionsBuilder builder_(_fbb);
9933	return builder_.Finish();
9934	}
9935
9936	flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
9937
9938	struct ReverseSequenceOptionsT : public flatbuffers::NativeTable {
9939	typedef ReverseSequenceOptions TableType;
9940	int32_t seq_dim = `0`;
9941	int32_t batch_dim = `0`;
9942	};
9943
9944	struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9945	typedef ReverseSequenceOptionsT NativeTableType;
9946	typedef ReverseSequenceOptionsBuilder Builder;
9947	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9948	VT_SEQ_DIM = `4`,
9949	VT_BATCH_DIM = `6`
9950	};
9951	int32_t seq_dim() const {
9952	return GetField<int32_t>(VT_SEQ_DIM, `0`);
9953	}
9954	int32_t batch_dim() const {
9955	return GetField<int32_t>(VT_BATCH_DIM, `0`);
9956	}
9957	bool Verify(flatbuffers::Verifier &verifier) const {
9958	return VerifyTableStart(verifier) &&
9959	VerifyField<int32_t>(verifier, VT_SEQ_DIM, `4`) &&
9960	VerifyField<int32_t>(verifier, VT_BATCH_DIM, `4`) &&
9961	verifier.EndTable();
9962	}
9963	ReverseSequenceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9964	void UnPackTo(ReverseSequenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
9965	static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
9966	};
9967
9968	struct ReverseSequenceOptionsBuilder {
9969	typedef ReverseSequenceOptions Table;
9970	flatbuffers::FlatBufferBuilder &fbb_;
9971	flatbuffers::uoffset_t start_;
9972	void add_seq_dim(int32_t seq_dim) {
9973	fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, `0`);
9974	}
9975	void add_batch_dim(int32_t batch_dim) {
9976	fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, `0`);
9977	}
9978	explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
9979	: fbb_(_fbb) {
9980	start_ = fbb_.StartTable();
9981	}
9982	flatbuffers::Offset<ReverseSequenceOptions> Finish() {
9983	const auto end = fbb_.EndTable(start_);
9984	auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
9985	return o;
9986	}
9987	};
9988
9989	inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
9990	flatbuffers::FlatBufferBuilder &_fbb,
9991	int32_t seq_dim = `0`,
9992	int32_t batch_dim = `0`) {
9993	ReverseSequenceOptionsBuilder builder_(_fbb);
9994	builder_.add_batch_dim(batch_dim);
9995	builder_.add_seq_dim(seq_dim);
9996	return builder_.Finish();
9997	}
9998
9999	flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10000
10001	struct MatrixDiagOptionsT : public flatbuffers::NativeTable {
10002	typedef MatrixDiagOptions TableType;
10003	};
10004
10005	struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10006	typedef MatrixDiagOptionsT NativeTableType;
10007	typedef MatrixDiagOptionsBuilder Builder;
10008	bool Verify(flatbuffers::Verifier &verifier) const {
10009	return VerifyTableStart(verifier) &&
10010	verifier.EndTable();
10011	}
10012	MatrixDiagOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10013	void UnPackTo(MatrixDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10014	static flatbuffers::Offset<MatrixDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10015	};
10016
10017	struct MatrixDiagOptionsBuilder {
10018	typedef MatrixDiagOptions Table;
10019	flatbuffers::FlatBufferBuilder &fbb_;
10020	flatbuffers::uoffset_t start_;
10021	explicit MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10022	: fbb_(_fbb) {
10023	start_ = fbb_.StartTable();
10024	}
10025	flatbuffers::Offset<MatrixDiagOptions> Finish() {
10026	const auto end = fbb_.EndTable(start_);
10027	auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
10028	return o;
10029	}
10030	};
10031
10032	inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
10033	flatbuffers::FlatBufferBuilder &_fbb) {
10034	MatrixDiagOptionsBuilder builder_(_fbb);
10035	return builder_.Finish();
10036	}
10037
10038	flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10039
10040	struct QuantizeOptionsT : public flatbuffers::NativeTable {
10041	typedef QuantizeOptions TableType;
10042	};
10043
10044	struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10045	typedef QuantizeOptionsT NativeTableType;
10046	typedef QuantizeOptionsBuilder Builder;
10047	bool Verify(flatbuffers::Verifier &verifier) const {
10048	return VerifyTableStart(verifier) &&
10049	verifier.EndTable();
10050	}
10051	QuantizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10052	void UnPackTo(QuantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10053	static flatbuffers::Offset<QuantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10054	};
10055
10056	struct QuantizeOptionsBuilder {
10057	typedef QuantizeOptions Table;
10058	flatbuffers::FlatBufferBuilder &fbb_;
10059	flatbuffers::uoffset_t start_;
10060	explicit QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10061	: fbb_(_fbb) {
10062	start_ = fbb_.StartTable();
10063	}
10064	flatbuffers::Offset<QuantizeOptions> Finish() {
10065	const auto end = fbb_.EndTable(start_);
10066	auto o = flatbuffers::Offset<QuantizeOptions>(end);
10067	return o;
10068	}
10069	};
10070
10071	inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
10072	flatbuffers::FlatBufferBuilder &_fbb) {
10073	QuantizeOptionsBuilder builder_(_fbb);
10074	return builder_.Finish();
10075	}
10076
10077	flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10078
10079	struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable {
10080	typedef MatrixSetDiagOptions TableType;
10081	};
10082
10083	struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10084	typedef MatrixSetDiagOptionsT NativeTableType;
10085	typedef MatrixSetDiagOptionsBuilder Builder;
10086	bool Verify(flatbuffers::Verifier &verifier) const {
10087	return VerifyTableStart(verifier) &&
10088	verifier.EndTable();
10089	}
10090	MatrixSetDiagOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10091	void UnPackTo(MatrixSetDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10092	static flatbuffers::Offset<MatrixSetDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10093	};
10094
10095	struct MatrixSetDiagOptionsBuilder {
10096	typedef MatrixSetDiagOptions Table;
10097	flatbuffers::FlatBufferBuilder &fbb_;
10098	flatbuffers::uoffset_t start_;
10099	explicit MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10100	: fbb_(_fbb) {
10101	start_ = fbb_.StartTable();
10102	}
10103	flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
10104	const auto end = fbb_.EndTable(start_);
10105	auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
10106	return o;
10107	}
10108	};
10109
10110	inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
10111	flatbuffers::FlatBufferBuilder &_fbb) {
10112	MatrixSetDiagOptionsBuilder builder_(_fbb);
10113	return builder_.Finish();
10114	}
10115
10116	flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10117
10118	struct IfOptionsT : public flatbuffers::NativeTable {
10119	typedef IfOptions TableType;
10120	int32_t then_subgraph_index = `0`;
10121	int32_t else_subgraph_index = `0`;
10122	};
10123
10124	struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10125	typedef IfOptionsT NativeTableType;
10126	typedef IfOptionsBuilder Builder;
10127	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10128	VT_THEN_SUBGRAPH_INDEX = `4`,
10129	VT_ELSE_SUBGRAPH_INDEX = `6`
10130	};
10131	int32_t then_subgraph_index() const {
10132	return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, `0`);
10133	}
10134	int32_t else_subgraph_index() const {
10135	return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, `0`);
10136	}
10137	bool Verify(flatbuffers::Verifier &verifier) const {
10138	return VerifyTableStart(verifier) &&
10139	VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX, `4`) &&
10140	VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX, `4`) &&
10141	verifier.EndTable();
10142	}
10143	IfOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10144	void UnPackTo(IfOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10145	static flatbuffers::Offset<IfOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10146	};
10147
10148	struct IfOptionsBuilder {
10149	typedef IfOptions Table;
10150	flatbuffers::FlatBufferBuilder &fbb_;
10151	flatbuffers::uoffset_t start_;
10152	void add_then_subgraph_index(int32_t then_subgraph_index) {
10153	fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, `0`);
10154	}
10155	void add_else_subgraph_index(int32_t else_subgraph_index) {
10156	fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, `0`);
10157	}
10158	explicit IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10159	: fbb_(_fbb) {
10160	start_ = fbb_.StartTable();
10161	}
10162	flatbuffers::Offset<IfOptions> Finish() {
10163	const auto end = fbb_.EndTable(start_);
10164	auto o = flatbuffers::Offset<IfOptions>(end);
10165	return o;
10166	}
10167	};
10168
10169	inline flatbuffers::Offset<IfOptions> CreateIfOptions(
10170	flatbuffers::FlatBufferBuilder &_fbb,
10171	int32_t then_subgraph_index = `0`,
10172	int32_t else_subgraph_index = `0`) {
10173	IfOptionsBuilder builder_(_fbb);
10174	builder_.add_else_subgraph_index(else_subgraph_index);
10175	builder_.add_then_subgraph_index(then_subgraph_index);
10176	return builder_.Finish();
10177	}
10178
10179	flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10180
10181	struct CallOnceOptionsT : public flatbuffers::NativeTable {
10182	typedef CallOnceOptions TableType;
10183	int32_t init_subgraph_index = `0`;
10184	};
10185
10186	struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10187	typedef CallOnceOptionsT NativeTableType;
10188	typedef CallOnceOptionsBuilder Builder;
10189	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10190	VT_INIT_SUBGRAPH_INDEX = `4`
10191	};
10192	int32_t init_subgraph_index() const {
10193	return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, `0`);
10194	}
10195	bool Verify(flatbuffers::Verifier &verifier) const {
10196	return VerifyTableStart(verifier) &&
10197	VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX, `4`) &&
10198	verifier.EndTable();
10199	}
10200	CallOnceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10201	void UnPackTo(CallOnceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10202	static flatbuffers::Offset<CallOnceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10203	};
10204
10205	struct CallOnceOptionsBuilder {
10206	typedef CallOnceOptions Table;
10207	flatbuffers::FlatBufferBuilder &fbb_;
10208	flatbuffers::uoffset_t start_;
10209	void add_init_subgraph_index(int32_t init_subgraph_index) {
10210	fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, `0`);
10211	}
10212	explicit CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10213	: fbb_(_fbb) {
10214	start_ = fbb_.StartTable();
10215	}
10216	flatbuffers::Offset<CallOnceOptions> Finish() {
10217	const auto end = fbb_.EndTable(start_);
10218	auto o = flatbuffers::Offset<CallOnceOptions>(end);
10219	return o;
10220	}
10221	};
10222
10223	inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
10224	flatbuffers::FlatBufferBuilder &_fbb,
10225	int32_t init_subgraph_index = `0`) {
10226	CallOnceOptionsBuilder builder_(_fbb);
10227	builder_.add_init_subgraph_index(init_subgraph_index);
10228	return builder_.Finish();
10229	}
10230
10231	flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10232
10233	struct WhileOptionsT : public flatbuffers::NativeTable {
10234	typedef WhileOptions TableType;
10235	int32_t cond_subgraph_index = `0`;
10236	int32_t body_subgraph_index = `0`;
10237	};
10238
10239	struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10240	typedef WhileOptionsT NativeTableType;
10241	typedef WhileOptionsBuilder Builder;
10242	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10243	VT_COND_SUBGRAPH_INDEX = `4`,
10244	VT_BODY_SUBGRAPH_INDEX = `6`
10245	};
10246	int32_t cond_subgraph_index() const {
10247	return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, `0`);
10248	}
10249	int32_t body_subgraph_index() const {
10250	return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, `0`);
10251	}
10252	bool Verify(flatbuffers::Verifier &verifier) const {
10253	return VerifyTableStart(verifier) &&
10254	VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, `4`) &&
10255	VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, `4`) &&
10256	verifier.EndTable();
10257	}
10258	WhileOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10259	void UnPackTo(WhileOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10260	static flatbuffers::Offset<WhileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10261	};
10262
10263	struct WhileOptionsBuilder {
10264	typedef WhileOptions Table;
10265	flatbuffers::FlatBufferBuilder &fbb_;
10266	flatbuffers::uoffset_t start_;
10267	void add_cond_subgraph_index(int32_t cond_subgraph_index) {
10268	fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, `0`);
10269	}
10270	void add_body_subgraph_index(int32_t body_subgraph_index) {
10271	fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, `0`);
10272	}
10273	explicit WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10274	: fbb_(_fbb) {
10275	start_ = fbb_.StartTable();
10276	}
10277	flatbuffers::Offset<WhileOptions> Finish() {
10278	const auto end = fbb_.EndTable(start_);
10279	auto o = flatbuffers::Offset<WhileOptions>(end);
10280	return o;
10281	}
10282	};
10283
10284	inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
10285	flatbuffers::FlatBufferBuilder &_fbb,
10286	int32_t cond_subgraph_index = `0`,
10287	int32_t body_subgraph_index = `0`) {
10288	WhileOptionsBuilder builder_(_fbb);
10289	builder_.add_body_subgraph_index(body_subgraph_index);
10290	builder_.add_cond_subgraph_index(cond_subgraph_index);
10291	return builder_.Finish();
10292	}
10293
10294	flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10295
10296	struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable {
10297	typedef NonMaxSuppressionV4Options TableType;
10298	};
10299
10300	struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10301	typedef NonMaxSuppressionV4OptionsT NativeTableType;
10302	typedef NonMaxSuppressionV4OptionsBuilder Builder;
10303	bool Verify(flatbuffers::Verifier &verifier) const {
10304	return VerifyTableStart(verifier) &&
10305	verifier.EndTable();
10306	}
10307	NonMaxSuppressionV4OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10308	void UnPackTo(NonMaxSuppressionV4OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10309	static flatbuffers::Offset<NonMaxSuppressionV4Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10310	};
10311
10312	struct NonMaxSuppressionV4OptionsBuilder {
10313	typedef NonMaxSuppressionV4Options Table;
10314	flatbuffers::FlatBufferBuilder &fbb_;
10315	flatbuffers::uoffset_t start_;
10316	explicit NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10317	: fbb_(_fbb) {
10318	start_ = fbb_.StartTable();
10319	}
10320	flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
10321	const auto end = fbb_.EndTable(start_);
10322	auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
10323	return o;
10324	}
10325	};
10326
10327	inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
10328	flatbuffers::FlatBufferBuilder &_fbb) {
10329	NonMaxSuppressionV4OptionsBuilder builder_(_fbb);
10330	return builder_.Finish();
10331	}
10332
10333	flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10334
10335	struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable {
10336	typedef NonMaxSuppressionV5Options TableType;
10337	};
10338
10339	struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10340	typedef NonMaxSuppressionV5OptionsT NativeTableType;
10341	typedef NonMaxSuppressionV5OptionsBuilder Builder;
10342	bool Verify(flatbuffers::Verifier &verifier) const {
10343	return VerifyTableStart(verifier) &&
10344	verifier.EndTable();
10345	}
10346	NonMaxSuppressionV5OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10347	void UnPackTo(NonMaxSuppressionV5OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10348	static flatbuffers::Offset<NonMaxSuppressionV5Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10349	};
10350
10351	struct NonMaxSuppressionV5OptionsBuilder {
10352	typedef NonMaxSuppressionV5Options Table;
10353	flatbuffers::FlatBufferBuilder &fbb_;
10354	flatbuffers::uoffset_t start_;
10355	explicit NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10356	: fbb_(_fbb) {
10357	start_ = fbb_.StartTable();
10358	}
10359	flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
10360	const auto end = fbb_.EndTable(start_);
10361	auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
10362	return o;
10363	}
10364	};
10365
10366	inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
10367	flatbuffers::FlatBufferBuilder &_fbb) {
10368	NonMaxSuppressionV5OptionsBuilder builder_(_fbb);
10369	return builder_.Finish();
10370	}
10371
10372	flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10373
10374	struct ScatterNdOptionsT : public flatbuffers::NativeTable {
10375	typedef ScatterNdOptions TableType;
10376	};
10377
10378	struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10379	typedef ScatterNdOptionsT NativeTableType;
10380	typedef ScatterNdOptionsBuilder Builder;
10381	bool Verify(flatbuffers::Verifier &verifier) const {
10382	return VerifyTableStart(verifier) &&
10383	verifier.EndTable();
10384	}
10385	ScatterNdOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10386	void UnPackTo(ScatterNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10387	static flatbuffers::Offset<ScatterNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10388	};
10389
10390	struct ScatterNdOptionsBuilder {
10391	typedef ScatterNdOptions Table;
10392	flatbuffers::FlatBufferBuilder &fbb_;
10393	flatbuffers::uoffset_t start_;
10394	explicit ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10395	: fbb_(_fbb) {
10396	start_ = fbb_.StartTable();
10397	}
10398	flatbuffers::Offset<ScatterNdOptions> Finish() {
10399	const auto end = fbb_.EndTable(start_);
10400	auto o = flatbuffers::Offset<ScatterNdOptions>(end);
10401	return o;
10402	}
10403	};
10404
10405	inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
10406	flatbuffers::FlatBufferBuilder &_fbb) {
10407	ScatterNdOptionsBuilder builder_(_fbb);
10408	return builder_.Finish();
10409	}
10410
10411	flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10412
10413	struct SelectV2OptionsT : public flatbuffers::NativeTable {
10414	typedef SelectV2Options TableType;
10415	};
10416
10417	struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10418	typedef SelectV2OptionsT NativeTableType;
10419	typedef SelectV2OptionsBuilder Builder;
10420	bool Verify(flatbuffers::Verifier &verifier) const {
10421	return VerifyTableStart(verifier) &&
10422	verifier.EndTable();
10423	}
10424	SelectV2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10425	void UnPackTo(SelectV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10426	static flatbuffers::Offset<SelectV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10427	};
10428
10429	struct SelectV2OptionsBuilder {
10430	typedef SelectV2Options Table;
10431	flatbuffers::FlatBufferBuilder &fbb_;
10432	flatbuffers::uoffset_t start_;
10433	explicit SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10434	: fbb_(_fbb) {
10435	start_ = fbb_.StartTable();
10436	}
10437	flatbuffers::Offset<SelectV2Options> Finish() {
10438	const auto end = fbb_.EndTable(start_);
10439	auto o = flatbuffers::Offset<SelectV2Options>(end);
10440	return o;
10441	}
10442	};
10443
10444	inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
10445	flatbuffers::FlatBufferBuilder &_fbb) {
10446	SelectV2OptionsBuilder builder_(_fbb);
10447	return builder_.Finish();
10448	}
10449
10450	flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10451
10452	struct DensifyOptionsT : public flatbuffers::NativeTable {
10453	typedef DensifyOptions TableType;
10454	};
10455
10456	struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10457	typedef DensifyOptionsT NativeTableType;
10458	typedef DensifyOptionsBuilder Builder;
10459	bool Verify(flatbuffers::Verifier &verifier) const {
10460	return VerifyTableStart(verifier) &&
10461	verifier.EndTable();
10462	}
10463	DensifyOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10464	void UnPackTo(DensifyOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10465	static flatbuffers::Offset<DensifyOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10466	};
10467
10468	struct DensifyOptionsBuilder {
10469	typedef DensifyOptions Table;
10470	flatbuffers::FlatBufferBuilder &fbb_;
10471	flatbuffers::uoffset_t start_;
10472	explicit DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10473	: fbb_(_fbb) {
10474	start_ = fbb_.StartTable();
10475	}
10476	flatbuffers::Offset<DensifyOptions> Finish() {
10477	const auto end = fbb_.EndTable(start_);
10478	auto o = flatbuffers::Offset<DensifyOptions>(end);
10479	return o;
10480	}
10481	};
10482
10483	inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
10484	flatbuffers::FlatBufferBuilder &_fbb) {
10485	DensifyOptionsBuilder builder_(_fbb);
10486	return builder_.Finish();
10487	}
10488
10489	flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10490
10491	struct SegmentSumOptionsT : public flatbuffers::NativeTable {
10492	typedef SegmentSumOptions TableType;
10493	};
10494
10495	struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10496	typedef SegmentSumOptionsT NativeTableType;
10497	typedef SegmentSumOptionsBuilder Builder;
10498	bool Verify(flatbuffers::Verifier &verifier) const {
10499	return VerifyTableStart(verifier) &&
10500	verifier.EndTable();
10501	}
10502	SegmentSumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10503	void UnPackTo(SegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10504	static flatbuffers::Offset<SegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10505	};
10506
10507	struct SegmentSumOptionsBuilder {
10508	typedef SegmentSumOptions Table;
10509	flatbuffers::FlatBufferBuilder &fbb_;
10510	flatbuffers::uoffset_t start_;
10511	explicit SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10512	: fbb_(_fbb) {
10513	start_ = fbb_.StartTable();
10514	}
10515	flatbuffers::Offset<SegmentSumOptions> Finish() {
10516	const auto end = fbb_.EndTable(start_);
10517	auto o = flatbuffers::Offset<SegmentSumOptions>(end);
10518	return o;
10519	}
10520	};
10521
10522	inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
10523	flatbuffers::FlatBufferBuilder &_fbb) {
10524	SegmentSumOptionsBuilder builder_(_fbb);
10525	return builder_.Finish();
10526	}
10527
10528	flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10529
10530	struct BatchMatMulOptionsT : public flatbuffers::NativeTable {
10531	typedef BatchMatMulOptions TableType;
10532	bool adj_x = false;
10533	bool adj_y = false;
10534	bool asymmetric_quantize_inputs = false;
10535	};
10536
10537	struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10538	typedef BatchMatMulOptionsT NativeTableType;
10539	typedef BatchMatMulOptionsBuilder Builder;
10540	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10541	VT_ADJ_X = `4`,
10542	VT_ADJ_Y = `6`,
10543	VT_ASYMMETRIC_QUANTIZE_INPUTS = `8`
10544	};
10545	bool adj_x() const {
10546	return GetField<uint8_t>(VT_ADJ_X, `0`) != `0`;
10547	}
10548	bool adj_y() const {
10549	return GetField<uint8_t>(VT_ADJ_Y, `0`) != `0`;
10550	}
10551	bool asymmetric_quantize_inputs() const {
10552	return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, `0`) != `0`;
10553	}
10554	bool Verify(flatbuffers::Verifier &verifier) const {
10555	return VerifyTableStart(verifier) &&
10556	VerifyField<uint8_t>(verifier, VT_ADJ_X, `1`) &&
10557	VerifyField<uint8_t>(verifier, VT_ADJ_Y, `1`) &&
10558	VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, `1`) &&
10559	verifier.EndTable();
10560	}
10561	BatchMatMulOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10562	void UnPackTo(BatchMatMulOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10563	static flatbuffers::Offset<BatchMatMulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10564	};
10565
10566	struct BatchMatMulOptionsBuilder {
10567	typedef BatchMatMulOptions Table;
10568	flatbuffers::FlatBufferBuilder &fbb_;
10569	flatbuffers::uoffset_t start_;
10570	void add_adj_x(bool adj_x) {
10571	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), `0`);
10572	}
10573	void add_adj_y(bool adj_y) {
10574	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), `0`);
10575	}
10576	void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
10577	fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), `0`);
10578	}
10579	explicit BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10580	: fbb_(_fbb) {
10581	start_ = fbb_.StartTable();
10582	}
10583	flatbuffers::Offset<BatchMatMulOptions> Finish() {
10584	const auto end = fbb_.EndTable(start_);
10585	auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
10586	return o;
10587	}
10588	};
10589
10590	inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
10591	flatbuffers::FlatBufferBuilder &_fbb,
10592	bool adj_x = false,
10593	bool adj_y = false,
10594	bool asymmetric_quantize_inputs = false) {
10595	BatchMatMulOptionsBuilder builder_(_fbb);
10596	builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
10597	builder_.add_adj_y(adj_y);
10598	builder_.add_adj_x(adj_x);
10599	return builder_.Finish();
10600	}
10601
10602	flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10603
10604	struct CumsumOptionsT : public flatbuffers::NativeTable {
10605	typedef CumsumOptions TableType;
10606	bool exclusive = false;
10607	bool reverse = false;
10608	};
10609
10610	struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10611	typedef CumsumOptionsT NativeTableType;
10612	typedef CumsumOptionsBuilder Builder;
10613	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10614	VT_EXCLUSIVE = `4`,
10615	VT_REVERSE = `6`
10616	};
10617	bool exclusive() const {
10618	return GetField<uint8_t>(VT_EXCLUSIVE, `0`) != `0`;
10619	}
10620	bool reverse() const {
10621	return GetField<uint8_t>(VT_REVERSE, `0`) != `0`;
10622	}
10623	bool Verify(flatbuffers::Verifier &verifier) const {
10624	return VerifyTableStart(verifier) &&
10625	VerifyField<uint8_t>(verifier, VT_EXCLUSIVE, `1`) &&
10626	VerifyField<uint8_t>(verifier, VT_REVERSE, `1`) &&
10627	verifier.EndTable();
10628	}
10629	CumsumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10630	void UnPackTo(CumsumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10631	static flatbuffers::Offset<CumsumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10632	};
10633
10634	struct CumsumOptionsBuilder {
10635	typedef CumsumOptions Table;
10636	flatbuffers::FlatBufferBuilder &fbb_;
10637	flatbuffers::uoffset_t start_;
10638	void add_exclusive(bool exclusive) {
10639	fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), `0`);
10640	}
10641	void add_reverse(bool reverse) {
10642	fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), `0`);
10643	}
10644	explicit CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10645	: fbb_(_fbb) {
10646	start_ = fbb_.StartTable();
10647	}
10648	flatbuffers::Offset<CumsumOptions> Finish() {
10649	const auto end = fbb_.EndTable(start_);
10650	auto o = flatbuffers::Offset<CumsumOptions>(end);
10651	return o;
10652	}
10653	};
10654
10655	inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
10656	flatbuffers::FlatBufferBuilder &_fbb,
10657	bool exclusive = false,
10658	bool reverse = false) {
10659	CumsumOptionsBuilder builder_(_fbb);
10660	builder_.add_reverse(reverse);
10661	builder_.add_exclusive(exclusive);
10662	return builder_.Finish();
10663	}
10664
10665	flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10666
10667	struct BroadcastToOptionsT : public flatbuffers::NativeTable {
10668	typedef BroadcastToOptions TableType;
10669	};
10670
10671	struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10672	typedef BroadcastToOptionsT NativeTableType;
10673	typedef BroadcastToOptionsBuilder Builder;
10674	bool Verify(flatbuffers::Verifier &verifier) const {
10675	return VerifyTableStart(verifier) &&
10676	verifier.EndTable();
10677	}
10678	BroadcastToOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10679	void UnPackTo(BroadcastToOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10680	static flatbuffers::Offset<BroadcastToOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10681	};
10682
10683	struct BroadcastToOptionsBuilder {
10684	typedef BroadcastToOptions Table;
10685	flatbuffers::FlatBufferBuilder &fbb_;
10686	flatbuffers::uoffset_t start_;
10687	explicit BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10688	: fbb_(_fbb) {
10689	start_ = fbb_.StartTable();
10690	}
10691	flatbuffers::Offset<BroadcastToOptions> Finish() {
10692	const auto end = fbb_.EndTable(start_);
10693	auto o = flatbuffers::Offset<BroadcastToOptions>(end);
10694	return o;
10695	}
10696	};
10697
10698	inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
10699	flatbuffers::FlatBufferBuilder &_fbb) {
10700	BroadcastToOptionsBuilder builder_(_fbb);
10701	return builder_.Finish();
10702	}
10703
10704	flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10705
10706	struct Rfft2dOptionsT : public flatbuffers::NativeTable {
10707	typedef Rfft2dOptions TableType;
10708	};
10709
10710	struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10711	typedef Rfft2dOptionsT NativeTableType;
10712	typedef Rfft2dOptionsBuilder Builder;
10713	bool Verify(flatbuffers::Verifier &verifier) const {
10714	return VerifyTableStart(verifier) &&
10715	verifier.EndTable();
10716	}
10717	Rfft2dOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10718	void UnPackTo(Rfft2dOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10719	static flatbuffers::Offset<Rfft2dOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10720	};
10721
10722	struct Rfft2dOptionsBuilder {
10723	typedef Rfft2dOptions Table;
10724	flatbuffers::FlatBufferBuilder &fbb_;
10725	flatbuffers::uoffset_t start_;
10726	explicit Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10727	: fbb_(_fbb) {
10728	start_ = fbb_.StartTable();
10729	}
10730	flatbuffers::Offset<Rfft2dOptions> Finish() {
10731	const auto end = fbb_.EndTable(start_);
10732	auto o = flatbuffers::Offset<Rfft2dOptions>(end);
10733	return o;
10734	}
10735	};
10736
10737	inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
10738	flatbuffers::FlatBufferBuilder &_fbb) {
10739	Rfft2dOptionsBuilder builder_(_fbb);
10740	return builder_.Finish();
10741	}
10742
10743	flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10744
10745	struct HashtableOptionsT : public flatbuffers::NativeTable {
10746	typedef HashtableOptions TableType;
10747	int32_t table_id = `0`;
10748	tflite::TensorType key_dtype = tflite::TensorType_FLOAT32;
10749	tflite::TensorType value_dtype = tflite::TensorType_FLOAT32;
10750	};
10751
10752	struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10753	typedef HashtableOptionsT NativeTableType;
10754	typedef HashtableOptionsBuilder Builder;
10755	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10756	VT_TABLE_ID = `4`,
10757	VT_KEY_DTYPE = `6`,
10758	VT_VALUE_DTYPE = `8`
10759	};
10760	int32_t table_id() const {
10761	return GetField<int32_t>(VT_TABLE_ID, `0`);
10762	}
10763	tflite::TensorType key_dtype() const {
10764	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, `0`));
10765	}
10766	tflite::TensorType value_dtype() const {
10767	return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, `0`));
10768	}
10769	bool Verify(flatbuffers::Verifier &verifier) const {
10770	return VerifyTableStart(verifier) &&
10771	VerifyField<int32_t>(verifier, VT_TABLE_ID, `4`) &&
10772	VerifyField<int8_t>(verifier, VT_KEY_DTYPE, `1`) &&
10773	VerifyField<int8_t>(verifier, VT_VALUE_DTYPE, `1`) &&
10774	verifier.EndTable();
10775	}
10776	HashtableOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10777	void UnPackTo(HashtableOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10778	static flatbuffers::Offset<HashtableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10779	};
10780
10781	struct HashtableOptionsBuilder {
10782	typedef HashtableOptions Table;
10783	flatbuffers::FlatBufferBuilder &fbb_;
10784	flatbuffers::uoffset_t start_;
10785	void add_table_id(int32_t table_id) {
10786	fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, `0`);
10787	}
10788	void add_key_dtype(tflite::TensorType key_dtype) {
10789	fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), `0`);
10790	}
10791	void add_value_dtype(tflite::TensorType value_dtype) {
10792	fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), `0`);
10793	}
10794	explicit HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10795	: fbb_(_fbb) {
10796	start_ = fbb_.StartTable();
10797	}
10798	flatbuffers::Offset<HashtableOptions> Finish() {
10799	const auto end = fbb_.EndTable(start_);
10800	auto o = flatbuffers::Offset<HashtableOptions>(end);
10801	return o;
10802	}
10803	};
10804
10805	inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
10806	flatbuffers::FlatBufferBuilder &_fbb,
10807	int32_t table_id = `0`,
10808	tflite::TensorType key_dtype = tflite::TensorType_FLOAT32,
10809	tflite::TensorType value_dtype = tflite::TensorType_FLOAT32) {
10810	HashtableOptionsBuilder builder_(_fbb);
10811	builder_.add_table_id(table_id);
10812	builder_.add_value_dtype(value_dtype);
10813	builder_.add_key_dtype(key_dtype);
10814	return builder_.Finish();
10815	}
10816
10817	flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10818
10819	struct HashtableFindOptionsT : public flatbuffers::NativeTable {
10820	typedef HashtableFindOptions TableType;
10821	};
10822
10823	struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10824	typedef HashtableFindOptionsT NativeTableType;
10825	typedef HashtableFindOptionsBuilder Builder;
10826	bool Verify(flatbuffers::Verifier &verifier) const {
10827	return VerifyTableStart(verifier) &&
10828	verifier.EndTable();
10829	}
10830	HashtableFindOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10831	void UnPackTo(HashtableFindOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10832	static flatbuffers::Offset<HashtableFindOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10833	};
10834
10835	struct HashtableFindOptionsBuilder {
10836	typedef HashtableFindOptions Table;
10837	flatbuffers::FlatBufferBuilder &fbb_;
10838	flatbuffers::uoffset_t start_;
10839	explicit HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10840	: fbb_(_fbb) {
10841	start_ = fbb_.StartTable();
10842	}
10843	flatbuffers::Offset<HashtableFindOptions> Finish() {
10844	const auto end = fbb_.EndTable(start_);
10845	auto o = flatbuffers::Offset<HashtableFindOptions>(end);
10846	return o;
10847	}
10848	};
10849
10850	inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
10851	flatbuffers::FlatBufferBuilder &_fbb) {
10852	HashtableFindOptionsBuilder builder_(_fbb);
10853	return builder_.Finish();
10854	}
10855
10856	flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10857
10858	struct HashtableImportOptionsT : public flatbuffers::NativeTable {
10859	typedef HashtableImportOptions TableType;
10860	};
10861
10862	struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10863	typedef HashtableImportOptionsT NativeTableType;
10864	typedef HashtableImportOptionsBuilder Builder;
10865	bool Verify(flatbuffers::Verifier &verifier) const {
10866	return VerifyTableStart(verifier) &&
10867	verifier.EndTable();
10868	}
10869	HashtableImportOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10870	void UnPackTo(HashtableImportOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10871	static flatbuffers::Offset<HashtableImportOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10872	};
10873
10874	struct HashtableImportOptionsBuilder {
10875	typedef HashtableImportOptions Table;
10876	flatbuffers::FlatBufferBuilder &fbb_;
10877	flatbuffers::uoffset_t start_;
10878	explicit HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10879	: fbb_(_fbb) {
10880	start_ = fbb_.StartTable();
10881	}
10882	flatbuffers::Offset<HashtableImportOptions> Finish() {
10883	const auto end = fbb_.EndTable(start_);
10884	auto o = flatbuffers::Offset<HashtableImportOptions>(end);
10885	return o;
10886	}
10887	};
10888
10889	inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
10890	flatbuffers::FlatBufferBuilder &_fbb) {
10891	HashtableImportOptionsBuilder builder_(_fbb);
10892	return builder_.Finish();
10893	}
10894
10895	flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10896
10897	struct HashtableSizeOptionsT : public flatbuffers::NativeTable {
10898	typedef HashtableSizeOptions TableType;
10899	};
10900
10901	struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10902	typedef HashtableSizeOptionsT NativeTableType;
10903	typedef HashtableSizeOptionsBuilder Builder;
10904	bool Verify(flatbuffers::Verifier &verifier) const {
10905	return VerifyTableStart(verifier) &&
10906	verifier.EndTable();
10907	}
10908	HashtableSizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10909	void UnPackTo(HashtableSizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10910	static flatbuffers::Offset<HashtableSizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10911	};
10912
10913	struct HashtableSizeOptionsBuilder {
10914	typedef HashtableSizeOptions Table;
10915	flatbuffers::FlatBufferBuilder &fbb_;
10916	flatbuffers::uoffset_t start_;
10917	explicit HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10918	: fbb_(_fbb) {
10919	start_ = fbb_.StartTable();
10920	}
10921	flatbuffers::Offset<HashtableSizeOptions> Finish() {
10922	const auto end = fbb_.EndTable(start_);
10923	auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
10924	return o;
10925	}
10926	};
10927
10928	inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
10929	flatbuffers::FlatBufferBuilder &_fbb) {
10930	HashtableSizeOptionsBuilder builder_(_fbb);
10931	return builder_.Finish();
10932	}
10933
10934	flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
10935
10936	struct VarHandleOptionsT : public flatbuffers::NativeTable {
10937	typedef VarHandleOptions TableType;
10938	std::string container{};
10939	std::string shared_name{};
10940	};
10941
10942	struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10943	typedef VarHandleOptionsT NativeTableType;
10944	typedef VarHandleOptionsBuilder Builder;
10945	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10946	VT_CONTAINER = `4`,
10947	VT_SHARED_NAME = `6`
10948	};
10949	const flatbuffers::String container() const* {
10950	return GetPointer<const flatbuffers::String *>(VT_CONTAINER);
10951	}
10952	const flatbuffers::String shared_name() const* {
10953	return GetPointer<const flatbuffers::String *>(VT_SHARED_NAME);
10954	}
10955	bool Verify(flatbuffers::Verifier &verifier) const {
10956	return VerifyTableStart(verifier) &&
10957	VerifyOffset(verifier, VT_CONTAINER) &&
10958	verifier.VerifyString(container()) &&
10959	VerifyOffset(verifier, VT_SHARED_NAME) &&
10960	verifier.VerifyString(shared_name()) &&
10961	verifier.EndTable();
10962	}
10963	VarHandleOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10964	void UnPackTo(VarHandleOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
10965	static flatbuffers::Offset<VarHandleOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
10966	};
10967
10968	struct VarHandleOptionsBuilder {
10969	typedef VarHandleOptions Table;
10970	flatbuffers::FlatBufferBuilder &fbb_;
10971	flatbuffers::uoffset_t start_;
10972	void add_container(flatbuffers::Offset<flatbuffers::String> container) {
10973	fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container);
10974	}
10975	void add_shared_name(flatbuffers::Offset<flatbuffers::String> shared_name) {
10976	fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name);
10977	}
10978	explicit VarHandleOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
10979	: fbb_(_fbb) {
10980	start_ = fbb_.StartTable();
10981	}
10982	flatbuffers::Offset<VarHandleOptions> Finish() {
10983	const auto end = fbb_.EndTable(start_);
10984	auto o = flatbuffers::Offset<VarHandleOptions>(end);
10985	return o;
10986	}
10987	};
10988
10989	inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(
10990	flatbuffers::FlatBufferBuilder &_fbb,
10991	flatbuffers::Offset<flatbuffers::String> container = `0`,
10992	flatbuffers::Offset<flatbuffers::String> shared_name = `0`) {
10993	VarHandleOptionsBuilder builder_(_fbb);
10994	builder_.add_shared_name(shared_name);
10995	builder_.add_container(container);
10996	return builder_.Finish();
10997	}
10998
10999	inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptionsDirect(
11000	flatbuffers::FlatBufferBuilder &_fbb,
11001	const char container = nullptr*,
11002	const char shared_name = nullptr*) {
11003	auto container__ = container ? _fbb.CreateString(container) : `0`;
11004	auto shared_name__ = shared_name ? _fbb.CreateString(shared_name) : `0`;
11005	return tflite::CreateVarHandleOptions(
11006	_fbb,
11007	container__,
11008	shared_name__);
11009	}
11010
11011	flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11012
11013	struct ReadVariableOptionsT : public flatbuffers::NativeTable {
11014	typedef ReadVariableOptions TableType;
11015	};
11016
11017	struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11018	typedef ReadVariableOptionsT NativeTableType;
11019	typedef ReadVariableOptionsBuilder Builder;
11020	bool Verify(flatbuffers::Verifier &verifier) const {
11021	return VerifyTableStart(verifier) &&
11022	verifier.EndTable();
11023	}
11024	ReadVariableOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11025	void UnPackTo(ReadVariableOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11026	static flatbuffers::Offset<ReadVariableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11027	};
11028
11029	struct ReadVariableOptionsBuilder {
11030	typedef ReadVariableOptions Table;
11031	flatbuffers::FlatBufferBuilder &fbb_;
11032	flatbuffers::uoffset_t start_;
11033	explicit ReadVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11034	: fbb_(_fbb) {
11035	start_ = fbb_.StartTable();
11036	}
11037	flatbuffers::Offset<ReadVariableOptions> Finish() {
11038	const auto end = fbb_.EndTable(start_);
11039	auto o = flatbuffers::Offset<ReadVariableOptions>(end);
11040	return o;
11041	}
11042	};
11043
11044	inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(
11045	flatbuffers::FlatBufferBuilder &_fbb) {
11046	ReadVariableOptionsBuilder builder_(_fbb);
11047	return builder_.Finish();
11048	}
11049
11050	flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11051
11052	struct AssignVariableOptionsT : public flatbuffers::NativeTable {
11053	typedef AssignVariableOptions TableType;
11054	};
11055
11056	struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11057	typedef AssignVariableOptionsT NativeTableType;
11058	typedef AssignVariableOptionsBuilder Builder;
11059	bool Verify(flatbuffers::Verifier &verifier) const {
11060	return VerifyTableStart(verifier) &&
11061	verifier.EndTable();
11062	}
11063	AssignVariableOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11064	void UnPackTo(AssignVariableOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11065	static flatbuffers::Offset<AssignVariableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11066	};
11067
11068	struct AssignVariableOptionsBuilder {
11069	typedef AssignVariableOptions Table;
11070	flatbuffers::FlatBufferBuilder &fbb_;
11071	flatbuffers::uoffset_t start_;
11072	explicit AssignVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11073	: fbb_(_fbb) {
11074	start_ = fbb_.StartTable();
11075	}
11076	flatbuffers::Offset<AssignVariableOptions> Finish() {
11077	const auto end = fbb_.EndTable(start_);
11078	auto o = flatbuffers::Offset<AssignVariableOptions>(end);
11079	return o;
11080	}
11081	};
11082
11083	inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(
11084	flatbuffers::FlatBufferBuilder &_fbb) {
11085	AssignVariableOptionsBuilder builder_(_fbb);
11086	return builder_.Finish();
11087	}
11088
11089	flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11090
11091	struct RandomOptionsT : public flatbuffers::NativeTable {
11092	typedef RandomOptions TableType;
11093	int64_t seed = `0`;
11094	int64_t seed2 = `0`;
11095	};
11096
11097	struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11098	typedef RandomOptionsT NativeTableType;
11099	typedef RandomOptionsBuilder Builder;
11100	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11101	VT_SEED = `4`,
11102	VT_SEED2 = `6`
11103	};
11104	int64_t seed() const {
11105	return GetField<int64_t>(VT_SEED, `0`);
11106	}
11107	int64_t seed2() const {
11108	return GetField<int64_t>(VT_SEED2, `0`);
11109	}
11110	bool Verify(flatbuffers::Verifier &verifier) const {
11111	return VerifyTableStart(verifier) &&
11112	VerifyField<int64_t>(verifier, VT_SEED, `8`) &&
11113	VerifyField<int64_t>(verifier, VT_SEED2, `8`) &&
11114	verifier.EndTable();
11115	}
11116	RandomOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11117	void UnPackTo(RandomOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11118	static flatbuffers::Offset<RandomOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11119	};
11120
11121	struct RandomOptionsBuilder {
11122	typedef RandomOptions Table;
11123	flatbuffers::FlatBufferBuilder &fbb_;
11124	flatbuffers::uoffset_t start_;
11125	void add_seed(int64_t seed) {
11126	fbb_.AddElement<int64_t>(RandomOptions::VT_SEED, seed, `0`);
11127	}
11128	void add_seed2(int64_t seed2) {
11129	fbb_.AddElement<int64_t>(RandomOptions::VT_SEED2, seed2, `0`);
11130	}
11131	explicit RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11132	: fbb_(_fbb) {
11133	start_ = fbb_.StartTable();
11134	}
11135	flatbuffers::Offset<RandomOptions> Finish() {
11136	const auto end = fbb_.EndTable(start_);
11137	auto o = flatbuffers::Offset<RandomOptions>(end);
11138	return o;
11139	}
11140	};
11141
11142	inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(
11143	flatbuffers::FlatBufferBuilder &_fbb,
11144	int64_t seed = `0`,
11145	int64_t seed2 = `0`) {
11146	RandomOptionsBuilder builder_(_fbb);
11147	builder_.add_seed2(seed2);
11148	builder_.add_seed(seed);
11149	return builder_.Finish();
11150	}
11151
11152	flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11153
11154	struct BucketizeOptionsT : public flatbuffers::NativeTable {
11155	typedef BucketizeOptions TableType;
11156	std::vector<float> boundaries{};
11157	};
11158
11159	struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11160	typedef BucketizeOptionsT NativeTableType;
11161	typedef BucketizeOptionsBuilder Builder;
11162	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11163	VT_BOUNDARIES = `4`
11164	};
11165	const flatbuffers::Vector<float> boundaries() const* {
11166	return GetPointer<const flatbuffers::Vector<float> *>(VT_BOUNDARIES);
11167	}
11168	bool Verify(flatbuffers::Verifier &verifier) const {
11169	return VerifyTableStart(verifier) &&
11170	VerifyOffset(verifier, VT_BOUNDARIES) &&
11171	verifier.VerifyVector(boundaries()) &&
11172	verifier.EndTable();
11173	}
11174	BucketizeOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11175	void UnPackTo(BucketizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11176	static flatbuffers::Offset<BucketizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11177	};
11178
11179	struct BucketizeOptionsBuilder {
11180	typedef BucketizeOptions Table;
11181	flatbuffers::FlatBufferBuilder &fbb_;
11182	flatbuffers::uoffset_t start_;
11183	void add_boundaries(flatbuffers::Offset<flatbuffers::Vector<float>> boundaries) {
11184	fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries);
11185	}
11186	explicit BucketizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11187	: fbb_(_fbb) {
11188	start_ = fbb_.StartTable();
11189	}
11190	flatbuffers::Offset<BucketizeOptions> Finish() {
11191	const auto end = fbb_.EndTable(start_);
11192	auto o = flatbuffers::Offset<BucketizeOptions>(end);
11193	return o;
11194	}
11195	};
11196
11197	inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(
11198	flatbuffers::FlatBufferBuilder &_fbb,
11199	flatbuffers::Offset<flatbuffers::Vector<float>> boundaries = `0`) {
11200	BucketizeOptionsBuilder builder_(_fbb);
11201	builder_.add_boundaries(boundaries);
11202	return builder_.Finish();
11203	}
11204
11205	inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptionsDirect(
11206	flatbuffers::FlatBufferBuilder &_fbb,
11207	const std::vector<float> boundaries = nullptr*) {
11208	auto boundaries__ = boundaries ? _fbb.CreateVector<float>(*boundaries) : `0`;
11209	return tflite::CreateBucketizeOptions(
11210	_fbb,
11211	boundaries__);
11212	}
11213
11214	flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11215
11216	struct GeluOptionsT : public flatbuffers::NativeTable {
11217	typedef GeluOptions TableType;
11218	bool approximate = false;
11219	};
11220
11221	struct GeluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11222	typedef GeluOptionsT NativeTableType;
11223	typedef GeluOptionsBuilder Builder;
11224	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11225	VT_APPROXIMATE = `4`
11226	};
11227	bool approximate() const {
11228	return GetField<uint8_t>(VT_APPROXIMATE, `0`) != `0`;
11229	}
11230	bool Verify(flatbuffers::Verifier &verifier) const {
11231	return VerifyTableStart(verifier) &&
11232	VerifyField<uint8_t>(verifier, VT_APPROXIMATE, `1`) &&
11233	verifier.EndTable();
11234	}
11235	GeluOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11236	void UnPackTo(GeluOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11237	static flatbuffers::Offset<GeluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11238	};
11239
11240	struct GeluOptionsBuilder {
11241	typedef GeluOptions Table;
11242	flatbuffers::FlatBufferBuilder &fbb_;
11243	flatbuffers::uoffset_t start_;
11244	void add_approximate(bool approximate) {
11245	fbb_.AddElement<uint8_t>(GeluOptions::VT_APPROXIMATE, static_cast<uint8_t>(approximate), `0`);
11246	}
11247	explicit GeluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11248	: fbb_(_fbb) {
11249	start_ = fbb_.StartTable();
11250	}
11251	flatbuffers::Offset<GeluOptions> Finish() {
11252	const auto end = fbb_.EndTable(start_);
11253	auto o = flatbuffers::Offset<GeluOptions>(end);
11254	return o;
11255	}
11256	};
11257
11258	inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(
11259	flatbuffers::FlatBufferBuilder &_fbb,
11260	bool approximate = false) {
11261	GeluOptionsBuilder builder_(_fbb);
11262	builder_.add_approximate(approximate);
11263	return builder_.Finish();
11264	}
11265
11266	flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11267
11268	struct DynamicUpdateSliceOptionsT : public flatbuffers::NativeTable {
11269	typedef DynamicUpdateSliceOptions TableType;
11270	};
11271
11272	struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11273	typedef DynamicUpdateSliceOptionsT NativeTableType;
11274	typedef DynamicUpdateSliceOptionsBuilder Builder;
11275	bool Verify(flatbuffers::Verifier &verifier) const {
11276	return VerifyTableStart(verifier) &&
11277	verifier.EndTable();
11278	}
11279	DynamicUpdateSliceOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11280	void UnPackTo(DynamicUpdateSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11281	static flatbuffers::Offset<DynamicUpdateSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11282	};
11283
11284	struct DynamicUpdateSliceOptionsBuilder {
11285	typedef DynamicUpdateSliceOptions Table;
11286	flatbuffers::FlatBufferBuilder &fbb_;
11287	flatbuffers::uoffset_t start_;
11288	explicit DynamicUpdateSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11289	: fbb_(_fbb) {
11290	start_ = fbb_.StartTable();
11291	}
11292	flatbuffers::Offset<DynamicUpdateSliceOptions> Finish() {
11293	const auto end = fbb_.EndTable(start_);
11294	auto o = flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
11295	return o;
11296	}
11297	};
11298
11299	inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(
11300	flatbuffers::FlatBufferBuilder &_fbb) {
11301	DynamicUpdateSliceOptionsBuilder builder_(_fbb);
11302	return builder_.Finish();
11303	}
11304
11305	flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11306
11307	struct UnsortedSegmentProdOptionsT : public flatbuffers::NativeTable {
11308	typedef UnsortedSegmentProdOptions TableType;
11309	};
11310
11311	struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11312	typedef UnsortedSegmentProdOptionsT NativeTableType;
11313	typedef UnsortedSegmentProdOptionsBuilder Builder;
11314	bool Verify(flatbuffers::Verifier &verifier) const {
11315	return VerifyTableStart(verifier) &&
11316	verifier.EndTable();
11317	}
11318	UnsortedSegmentProdOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11319	void UnPackTo(UnsortedSegmentProdOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11320	static flatbuffers::Offset<UnsortedSegmentProdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11321	};
11322
11323	struct UnsortedSegmentProdOptionsBuilder {
11324	typedef UnsortedSegmentProdOptions Table;
11325	flatbuffers::FlatBufferBuilder &fbb_;
11326	flatbuffers::uoffset_t start_;
11327	explicit UnsortedSegmentProdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11328	: fbb_(_fbb) {
11329	start_ = fbb_.StartTable();
11330	}
11331	flatbuffers::Offset<UnsortedSegmentProdOptions> Finish() {
11332	const auto end = fbb_.EndTable(start_);
11333	auto o = flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
11334	return o;
11335	}
11336	};
11337
11338	inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(
11339	flatbuffers::FlatBufferBuilder &_fbb) {
11340	UnsortedSegmentProdOptionsBuilder builder_(_fbb);
11341	return builder_.Finish();
11342	}
11343
11344	flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11345
11346	struct UnsortedSegmentMaxOptionsT : public flatbuffers::NativeTable {
11347	typedef UnsortedSegmentMaxOptions TableType;
11348	};
11349
11350	struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11351	typedef UnsortedSegmentMaxOptionsT NativeTableType;
11352	typedef UnsortedSegmentMaxOptionsBuilder Builder;
11353	bool Verify(flatbuffers::Verifier &verifier) const {
11354	return VerifyTableStart(verifier) &&
11355	verifier.EndTable();
11356	}
11357	UnsortedSegmentMaxOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11358	void UnPackTo(UnsortedSegmentMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11359	static flatbuffers::Offset<UnsortedSegmentMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11360	};
11361
11362	struct UnsortedSegmentMaxOptionsBuilder {
11363	typedef UnsortedSegmentMaxOptions Table;
11364	flatbuffers::FlatBufferBuilder &fbb_;
11365	flatbuffers::uoffset_t start_;
11366	explicit UnsortedSegmentMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11367	: fbb_(_fbb) {
11368	start_ = fbb_.StartTable();
11369	}
11370	flatbuffers::Offset<UnsortedSegmentMaxOptions> Finish() {
11371	const auto end = fbb_.EndTable(start_);
11372	auto o = flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
11373	return o;
11374	}
11375	};
11376
11377	inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(
11378	flatbuffers::FlatBufferBuilder &_fbb) {
11379	UnsortedSegmentMaxOptionsBuilder builder_(_fbb);
11380	return builder_.Finish();
11381	}
11382
11383	flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11384
11385	struct UnsortedSegmentSumOptionsT : public flatbuffers::NativeTable {
11386	typedef UnsortedSegmentSumOptions TableType;
11387	};
11388
11389	struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11390	typedef UnsortedSegmentSumOptionsT NativeTableType;
11391	typedef UnsortedSegmentSumOptionsBuilder Builder;
11392	bool Verify(flatbuffers::Verifier &verifier) const {
11393	return VerifyTableStart(verifier) &&
11394	verifier.EndTable();
11395	}
11396	UnsortedSegmentSumOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11397	void UnPackTo(UnsortedSegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11398	static flatbuffers::Offset<UnsortedSegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11399	};
11400
11401	struct UnsortedSegmentSumOptionsBuilder {
11402	typedef UnsortedSegmentSumOptions Table;
11403	flatbuffers::FlatBufferBuilder &fbb_;
11404	flatbuffers::uoffset_t start_;
11405	explicit UnsortedSegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11406	: fbb_(_fbb) {
11407	start_ = fbb_.StartTable();
11408	}
11409	flatbuffers::Offset<UnsortedSegmentSumOptions> Finish() {
11410	const auto end = fbb_.EndTable(start_);
11411	auto o = flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
11412	return o;
11413	}
11414	};
11415
11416	inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(
11417	flatbuffers::FlatBufferBuilder &_fbb) {
11418	UnsortedSegmentSumOptionsBuilder builder_(_fbb);
11419	return builder_.Finish();
11420	}
11421
11422	flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11423
11424	struct ATan2OptionsT : public flatbuffers::NativeTable {
11425	typedef ATan2Options TableType;
11426	};
11427
11428	struct ATan2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11429	typedef ATan2OptionsT NativeTableType;
11430	typedef ATan2OptionsBuilder Builder;
11431	bool Verify(flatbuffers::Verifier &verifier) const {
11432	return VerifyTableStart(verifier) &&
11433	verifier.EndTable();
11434	}
11435	ATan2OptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11436	void UnPackTo(ATan2OptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11437	static flatbuffers::Offset<ATan2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11438	};
11439
11440	struct ATan2OptionsBuilder {
11441	typedef ATan2Options Table;
11442	flatbuffers::FlatBufferBuilder &fbb_;
11443	flatbuffers::uoffset_t start_;
11444	explicit ATan2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11445	: fbb_(_fbb) {
11446	start_ = fbb_.StartTable();
11447	}
11448	flatbuffers::Offset<ATan2Options> Finish() {
11449	const auto end = fbb_.EndTable(start_);
11450	auto o = flatbuffers::Offset<ATan2Options>(end);
11451	return o;
11452	}
11453	};
11454
11455	inline flatbuffers::Offset<ATan2Options> CreateATan2Options(
11456	flatbuffers::FlatBufferBuilder &_fbb) {
11457	ATan2OptionsBuilder builder_(_fbb);
11458	return builder_.Finish();
11459	}
11460
11461	flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11462
11463	struct UnsortedSegmentMinOptionsT : public flatbuffers::NativeTable {
11464	typedef UnsortedSegmentMinOptions TableType;
11465	};
11466
11467	struct UnsortedSegmentMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11468	typedef UnsortedSegmentMinOptionsT NativeTableType;
11469	typedef UnsortedSegmentMinOptionsBuilder Builder;
11470	bool Verify(flatbuffers::Verifier &verifier) const {
11471	return VerifyTableStart(verifier) &&
11472	verifier.EndTable();
11473	}
11474	UnsortedSegmentMinOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11475	void UnPackTo(UnsortedSegmentMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11476	static flatbuffers::Offset<UnsortedSegmentMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11477	};
11478
11479	struct UnsortedSegmentMinOptionsBuilder {
11480	typedef UnsortedSegmentMinOptions Table;
11481	flatbuffers::FlatBufferBuilder &fbb_;
11482	flatbuffers::uoffset_t start_;
11483	explicit UnsortedSegmentMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11484	: fbb_(_fbb) {
11485	start_ = fbb_.StartTable();
11486	}
11487	flatbuffers::Offset<UnsortedSegmentMinOptions> Finish() {
11488	const auto end = fbb_.EndTable(start_);
11489	auto o = flatbuffers::Offset<UnsortedSegmentMinOptions>(end);
11490	return o;
11491	}
11492	};
11493
11494	inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(
11495	flatbuffers::FlatBufferBuilder &_fbb) {
11496	UnsortedSegmentMinOptionsBuilder builder_(_fbb);
11497	return builder_.Finish();
11498	}
11499
11500	flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11501
11502	struct SignOptionsT : public flatbuffers::NativeTable {
11503	typedef SignOptions TableType;
11504	};
11505
11506	struct SignOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11507	typedef SignOptionsT NativeTableType;
11508	typedef SignOptionsBuilder Builder;
11509	bool Verify(flatbuffers::Verifier &verifier) const {
11510	return VerifyTableStart(verifier) &&
11511	verifier.EndTable();
11512	}
11513	SignOptionsT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11514	void UnPackTo(SignOptionsT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11515	static flatbuffers::Offset<SignOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11516	};
11517
11518	struct SignOptionsBuilder {
11519	typedef SignOptions Table;
11520	flatbuffers::FlatBufferBuilder &fbb_;
11521	flatbuffers::uoffset_t start_;
11522	explicit SignOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11523	: fbb_(_fbb) {
11524	start_ = fbb_.StartTable();
11525	}
11526	flatbuffers::Offset<SignOptions> Finish() {
11527	const auto end = fbb_.EndTable(start_);
11528	auto o = flatbuffers::Offset<SignOptions>(end);
11529	return o;
11530	}
11531	};
11532
11533	inline flatbuffers::Offset<SignOptions> CreateSignOptions(
11534	flatbuffers::FlatBufferBuilder &_fbb) {
11535	SignOptionsBuilder builder_(_fbb);
11536	return builder_.Finish();
11537	}
11538
11539	flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11540
11541	struct OperatorCodeT : public flatbuffers::NativeTable {
11542	typedef OperatorCode TableType;
11543	int8_t deprecated_builtin_code = `0`;
11544	std::string custom_code{};
11545	int32_t version = `1`;
11546	tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD;
11547	};
11548
11549	struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11550	typedef OperatorCodeT NativeTableType;
11551	typedef OperatorCodeBuilder Builder;
11552	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11553	VT_DEPRECATED_BUILTIN_CODE = `4`,
11554	VT_CUSTOM_CODE = `6`,
11555	VT_VERSION = `8`,
11556	VT_BUILTIN_CODE = `10`
11557	};
11558	int8_t deprecated_builtin_code() const {
11559	return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, `0`);
11560	}
11561	const flatbuffers::String custom_code() const* {
11562	return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
11563	}
11564	int32_t version() const {
11565	return GetField<int32_t>(VT_VERSION, `1`);
11566	}
11567	tflite::BuiltinOperator builtin_code() const {
11568	return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, `0`));
11569	}
11570	bool Verify(flatbuffers::Verifier &verifier) const {
11571	return VerifyTableStart(verifier) &&
11572	VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE, `1`) &&
11573	VerifyOffset(verifier, VT_CUSTOM_CODE) &&
11574	verifier.VerifyString(custom_code()) &&
11575	VerifyField<int32_t>(verifier, VT_VERSION, `4`) &&
11576	VerifyField<int32_t>(verifier, VT_BUILTIN_CODE, `4`) &&
11577	verifier.EndTable();
11578	}
11579	OperatorCodeT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11580	void UnPackTo(OperatorCodeT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
11581	static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
11582	};
11583
11584	struct OperatorCodeBuilder {
11585	typedef OperatorCode Table;
11586	flatbuffers::FlatBufferBuilder &fbb_;
11587	flatbuffers::uoffset_t start_;
11588	void add_deprecated_builtin_code(int8_t deprecated_builtin_code) {
11589	fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, `0`);
11590	}
11591	void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
11592	fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
11593	}
11594	void add_version(int32_t version) {
11595	fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, `1`);
11596	}
11597	void add_builtin_code(tflite::BuiltinOperator builtin_code) {
11598	fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), `0`);
11599	}
11600	explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
11601	: fbb_(_fbb) {
11602	start_ = fbb_.StartTable();
11603	}
11604	flatbuffers::Offset<OperatorCode> Finish() {
11605	const auto end = fbb_.EndTable(start_);
11606	auto o = flatbuffers::Offset<OperatorCode>(end);
11607	return o;
11608	}
11609	};
11610
11611	inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
11612	flatbuffers::FlatBufferBuilder &_fbb,
11613	int8_t deprecated_builtin_code = `0`,
11614	flatbuffers::Offset<flatbuffers::String> custom_code = `0`,
11615	int32_t version = `1`,
11616	tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
11617	OperatorCodeBuilder builder_(_fbb);
11618	builder_.add_builtin_code(builtin_code);
11619	builder_.add_version(version);
11620	builder_.add_custom_code(custom_code);
11621	builder_.add_deprecated_builtin_code(deprecated_builtin_code);
11622	return builder_.Finish();
11623	}
11624
11625	inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
11626	flatbuffers::FlatBufferBuilder &_fbb,
11627	int8_t deprecated_builtin_code = `0`,
11628	const char custom_code = nullptr*,
11629	int32_t version = `1`,
11630	tflite::BuiltinOperator builtin_code = tflite::BuiltinOperator_ADD) {
11631	auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : `0`;
11632	return tflite::CreateOperatorCode(
11633	_fbb,
11634	deprecated_builtin_code,
11635	custom_code__,
11636	version,
11637	builtin_code);
11638	}
11639
11640	flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
11641
11642	struct OperatorT : public flatbuffers::NativeTable {
11643	typedef Operator TableType;
11644	uint32_t opcode_index = `0`;
11645	std::vector<int32_t> inputs{};
11646	std::vector<int32_t> outputs{};
11647	tflite::BuiltinOptionsUnion builtin_options{};
11648	std::vector<uint8_t> custom_options{};
11649	tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS;
11650	std::vector<bool> mutating_variable_inputs{};
11651	std::vector<int32_t> intermediates{};
11652	};
11653
11654	struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11655	typedef OperatorT NativeTableType;
11656	typedef OperatorBuilder Builder;
11657	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11658	VT_OPCODE_INDEX = `4`,
11659	VT_INPUTS = `6`,
11660	VT_OUTPUTS = `8`,
11661	VT_BUILTIN_OPTIONS_TYPE = `10`,
11662	VT_BUILTIN_OPTIONS = `12`,
11663	VT_CUSTOM_OPTIONS = `14`,
11664	VT_CUSTOM_OPTIONS_FORMAT = `16`,
11665	VT_MUTATING_VARIABLE_INPUTS = `18`,
11666	VT_INTERMEDIATES = `20`
11667	};
11668	uint32_t opcode_index() const {
11669	return GetField<uint32_t>(VT_OPCODE_INDEX, `0`);
11670	}
11671	const flatbuffers::Vector<int32_t> inputs() const* {
11672	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
11673	}
11674	const flatbuffers::Vector<int32_t> outputs() const* {
11675	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
11676	}
11677	tflite::BuiltinOptions builtin_options_type() const {
11678	return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, `0`));
11679	}
11680	const void builtin_options() const* {
11681	return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
11682	}
11683	template<typename T> const T builtin_options_as() const*;
11684	const tflite::Conv2DOptions builtin_options_as_Conv2DOptions() const* {
11685	return builtin_options_type() == tflite::BuiltinOptions_Conv2DOptions ? static_cast<const tflite::Conv2DOptions >(builtin_options()) : nullptr*;
11686	}
11687	const tflite::DepthwiseConv2DOptions builtin_options_as_DepthwiseConv2DOptions() const* {
11688	return builtin_options_type() == tflite::BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const tflite::DepthwiseConv2DOptions >(builtin_options()) : nullptr*;
11689	}
11690	const tflite::ConcatEmbeddingsOptions builtin_options_as_ConcatEmbeddingsOptions() const* {
11691	return builtin_options_type() == tflite::BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const tflite::ConcatEmbeddingsOptions >(builtin_options()) : nullptr*;
11692	}
11693	const tflite::LSHProjectionOptions builtin_options_as_LSHProjectionOptions() const* {
11694	return builtin_options_type() == tflite::BuiltinOptions_LSHProjectionOptions ? static_cast<const tflite::LSHProjectionOptions >(builtin_options()) : nullptr*;
11695	}
11696	const tflite::Pool2DOptions builtin_options_as_Pool2DOptions() const* {
11697	return builtin_options_type() == tflite::BuiltinOptions_Pool2DOptions ? static_cast<const tflite::Pool2DOptions >(builtin_options()) : nullptr*;
11698	}
11699	const tflite::SVDFOptions builtin_options_as_SVDFOptions() const* {
11700	return builtin_options_type() == tflite::BuiltinOptions_SVDFOptions ? static_cast<const tflite::SVDFOptions >(builtin_options()) : nullptr*;
11701	}
11702	const tflite::RNNOptions builtin_options_as_RNNOptions() const* {
11703	return builtin_options_type() == tflite::BuiltinOptions_RNNOptions ? static_cast<const tflite::RNNOptions >(builtin_options()) : nullptr*;
11704	}
11705	const tflite::FullyConnectedOptions builtin_options_as_FullyConnectedOptions() const* {
11706	return builtin_options_type() == tflite::BuiltinOptions_FullyConnectedOptions ? static_cast<const tflite::FullyConnectedOptions >(builtin_options()) : nullptr*;
11707	}
11708	const tflite::SoftmaxOptions builtin_options_as_SoftmaxOptions() const* {
11709	return builtin_options_type() == tflite::BuiltinOptions_SoftmaxOptions ? static_cast<const tflite::SoftmaxOptions >(builtin_options()) : nullptr*;
11710	}
11711	const tflite::ConcatenationOptions builtin_options_as_ConcatenationOptions() const* {
11712	return builtin_options_type() == tflite::BuiltinOptions_ConcatenationOptions ? static_cast<const tflite::ConcatenationOptions >(builtin_options()) : nullptr*;
11713	}
11714	const tflite::AddOptions builtin_options_as_AddOptions() const* {
11715	return builtin_options_type() == tflite::BuiltinOptions_AddOptions ? static_cast<const tflite::AddOptions >(builtin_options()) : nullptr*;
11716	}
11717	const tflite::L2NormOptions builtin_options_as_L2NormOptions() const* {
11718	return builtin_options_type() == tflite::BuiltinOptions_L2NormOptions ? static_cast<const tflite::L2NormOptions >(builtin_options()) : nullptr*;
11719	}
11720	const tflite::LocalResponseNormalizationOptions builtin_options_as_LocalResponseNormalizationOptions() const* {
11721	return builtin_options_type() == tflite::BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const tflite::LocalResponseNormalizationOptions >(builtin_options()) : nullptr*;
11722	}
11723	const tflite::LSTMOptions builtin_options_as_LSTMOptions() const* {
11724	return builtin_options_type() == tflite::BuiltinOptions_LSTMOptions ? static_cast<const tflite::LSTMOptions >(builtin_options()) : nullptr*;
11725	}
11726	const tflite::ResizeBilinearOptions builtin_options_as_ResizeBilinearOptions() const* {
11727	return builtin_options_type() == tflite::BuiltinOptions_ResizeBilinearOptions ? static_cast<const tflite::ResizeBilinearOptions >(builtin_options()) : nullptr*;
11728	}
11729	const tflite::CallOptions builtin_options_as_CallOptions() const* {
11730	return builtin_options_type() == tflite::BuiltinOptions_CallOptions ? static_cast<const tflite::CallOptions >(builtin_options()) : nullptr*;
11731	}
11732	const tflite::ReshapeOptions builtin_options_as_ReshapeOptions() const* {
11733	return builtin_options_type() == tflite::BuiltinOptions_ReshapeOptions ? static_cast<const tflite::ReshapeOptions >(builtin_options()) : nullptr*;
11734	}
11735	const tflite::SkipGramOptions builtin_options_as_SkipGramOptions() const* {
11736	return builtin_options_type() == tflite::BuiltinOptions_SkipGramOptions ? static_cast<const tflite::SkipGramOptions >(builtin_options()) : nullptr*;
11737	}
11738	const tflite::SpaceToDepthOptions builtin_options_as_SpaceToDepthOptions() const* {
11739	return builtin_options_type() == tflite::BuiltinOptions_SpaceToDepthOptions ? static_cast<const tflite::SpaceToDepthOptions >(builtin_options()) : nullptr*;
11740	}
11741	const tflite::EmbeddingLookupSparseOptions builtin_options_as_EmbeddingLookupSparseOptions() const* {
11742	return builtin_options_type() == tflite::BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const tflite::EmbeddingLookupSparseOptions >(builtin_options()) : nullptr*;
11743	}
11744	const tflite::MulOptions builtin_options_as_MulOptions() const* {
11745	return builtin_options_type() == tflite::BuiltinOptions_MulOptions ? static_cast<const tflite::MulOptions >(builtin_options()) : nullptr*;
11746	}
11747	const tflite::PadOptions builtin_options_as_PadOptions() const* {
11748	return builtin_options_type() == tflite::BuiltinOptions_PadOptions ? static_cast<const tflite::PadOptions >(builtin_options()) : nullptr*;
11749	}
11750	const tflite::GatherOptions builtin_options_as_GatherOptions() const* {
11751	return builtin_options_type() == tflite::BuiltinOptions_GatherOptions ? static_cast<const tflite::GatherOptions >(builtin_options()) : nullptr*;
11752	}
11753	const tflite::BatchToSpaceNDOptions builtin_options_as_BatchToSpaceNDOptions() const* {
11754	return builtin_options_type() == tflite::BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const tflite::BatchToSpaceNDOptions >(builtin_options()) : nullptr*;
11755	}
11756	const tflite::SpaceToBatchNDOptions builtin_options_as_SpaceToBatchNDOptions() const* {
11757	return builtin_options_type() == tflite::BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const tflite::SpaceToBatchNDOptions >(builtin_options()) : nullptr*;
11758	}
11759	const tflite::TransposeOptions builtin_options_as_TransposeOptions() const* {
11760	return builtin_options_type() == tflite::BuiltinOptions_TransposeOptions ? static_cast<const tflite::TransposeOptions >(builtin_options()) : nullptr*;
11761	}
11762	const tflite::ReducerOptions builtin_options_as_ReducerOptions() const* {
11763	return builtin_options_type() == tflite::BuiltinOptions_ReducerOptions ? static_cast<const tflite::ReducerOptions >(builtin_options()) : nullptr*;
11764	}
11765	const tflite::SubOptions builtin_options_as_SubOptions() const* {
11766	return builtin_options_type() == tflite::BuiltinOptions_SubOptions ? static_cast<const tflite::SubOptions >(builtin_options()) : nullptr*;
11767	}
11768	const tflite::DivOptions builtin_options_as_DivOptions() const* {
11769	return builtin_options_type() == tflite::BuiltinOptions_DivOptions ? static_cast<const tflite::DivOptions >(builtin_options()) : nullptr*;
11770	}
11771	const tflite::SqueezeOptions builtin_options_as_SqueezeOptions() const* {
11772	return builtin_options_type() == tflite::BuiltinOptions_SqueezeOptions ? static_cast<const tflite::SqueezeOptions >(builtin_options()) : nullptr*;
11773	}
11774	const tflite::SequenceRNNOptions builtin_options_as_SequenceRNNOptions() const* {
11775	return builtin_options_type() == tflite::BuiltinOptions_SequenceRNNOptions ? static_cast<const tflite::SequenceRNNOptions >(builtin_options()) : nullptr*;
11776	}
11777	const tflite::StridedSliceOptions builtin_options_as_StridedSliceOptions() const* {
11778	return builtin_options_type() == tflite::BuiltinOptions_StridedSliceOptions ? static_cast<const tflite::StridedSliceOptions >(builtin_options()) : nullptr*;
11779	}
11780	const tflite::ExpOptions builtin_options_as_ExpOptions() const* {
11781	return builtin_options_type() == tflite::BuiltinOptions_ExpOptions ? static_cast<const tflite::ExpOptions >(builtin_options()) : nullptr*;
11782	}
11783	const tflite::TopKV2Options builtin_options_as_TopKV2Options() const* {
11784	return builtin_options_type() == tflite::BuiltinOptions_TopKV2Options ? static_cast<const tflite::TopKV2Options >(builtin_options()) : nullptr*;
11785	}
11786	const tflite::SplitOptions builtin_options_as_SplitOptions() const* {
11787	return builtin_options_type() == tflite::BuiltinOptions_SplitOptions ? static_cast<const tflite::SplitOptions >(builtin_options()) : nullptr*;
11788	}
11789	const tflite::LogSoftmaxOptions builtin_options_as_LogSoftmaxOptions() const* {
11790	return builtin_options_type() == tflite::BuiltinOptions_LogSoftmaxOptions ? static_cast<const tflite::LogSoftmaxOptions >(builtin_options()) : nullptr*;
11791	}
11792	const tflite::CastOptions builtin_options_as_CastOptions() const* {
11793	return builtin_options_type() == tflite::BuiltinOptions_CastOptions ? static_cast<const tflite::CastOptions >(builtin_options()) : nullptr*;
11794	}
11795	const tflite::DequantizeOptions builtin_options_as_DequantizeOptions() const* {
11796	return builtin_options_type() == tflite::BuiltinOptions_DequantizeOptions ? static_cast<const tflite::DequantizeOptions >(builtin_options()) : nullptr*;
11797	}
11798	const tflite::MaximumMinimumOptions builtin_options_as_MaximumMinimumOptions() const* {
11799	return builtin_options_type() == tflite::BuiltinOptions_MaximumMinimumOptions ? static_cast<const tflite::MaximumMinimumOptions >(builtin_options()) : nullptr*;
11800	}
11801	const tflite::ArgMaxOptions builtin_options_as_ArgMaxOptions() const* {
11802	return builtin_options_type() == tflite::BuiltinOptions_ArgMaxOptions ? static_cast<const tflite::ArgMaxOptions >(builtin_options()) : nullptr*;
11803	}
11804	const tflite::LessOptions builtin_options_as_LessOptions() const* {
11805	return builtin_options_type() == tflite::BuiltinOptions_LessOptions ? static_cast<const tflite::LessOptions >(builtin_options()) : nullptr*;
11806	}
11807	const tflite::NegOptions builtin_options_as_NegOptions() const* {
11808	return builtin_options_type() == tflite::BuiltinOptions_NegOptions ? static_cast<const tflite::NegOptions >(builtin_options()) : nullptr*;
11809	}
11810	const tflite::PadV2Options builtin_options_as_PadV2Options() const* {
11811	return builtin_options_type() == tflite::BuiltinOptions_PadV2Options ? static_cast<const tflite::PadV2Options >(builtin_options()) : nullptr*;
11812	}
11813	const tflite::GreaterOptions builtin_options_as_GreaterOptions() const* {
11814	return builtin_options_type() == tflite::BuiltinOptions_GreaterOptions ? static_cast<const tflite::GreaterOptions >(builtin_options()) : nullptr*;
11815	}
11816	const tflite::GreaterEqualOptions builtin_options_as_GreaterEqualOptions() const* {
11817	return builtin_options_type() == tflite::BuiltinOptions_GreaterEqualOptions ? static_cast<const tflite::GreaterEqualOptions >(builtin_options()) : nullptr*;
11818	}
11819	const tflite::LessEqualOptions builtin_options_as_LessEqualOptions() const* {
11820	return builtin_options_type() == tflite::BuiltinOptions_LessEqualOptions ? static_cast<const tflite::LessEqualOptions >(builtin_options()) : nullptr*;
11821	}
11822	const tflite::SelectOptions builtin_options_as_SelectOptions() const* {
11823	return builtin_options_type() == tflite::BuiltinOptions_SelectOptions ? static_cast<const tflite::SelectOptions >(builtin_options()) : nullptr*;
11824	}
11825	const tflite::SliceOptions builtin_options_as_SliceOptions() const* {
11826	return builtin_options_type() == tflite::BuiltinOptions_SliceOptions ? static_cast<const tflite::SliceOptions >(builtin_options()) : nullptr*;
11827	}
11828	const tflite::TransposeConvOptions builtin_options_as_TransposeConvOptions() const* {
11829	return builtin_options_type() == tflite::BuiltinOptions_TransposeConvOptions ? static_cast<const tflite::TransposeConvOptions >(builtin_options()) : nullptr*;
11830	}
11831	const tflite::SparseToDenseOptions builtin_options_as_SparseToDenseOptions() const* {
11832	return builtin_options_type() == tflite::BuiltinOptions_SparseToDenseOptions ? static_cast<const tflite::SparseToDenseOptions >(builtin_options()) : nullptr*;
11833	}
11834	const tflite::TileOptions builtin_options_as_TileOptions() const* {
11835	return builtin_options_type() == tflite::BuiltinOptions_TileOptions ? static_cast<const tflite::TileOptions >(builtin_options()) : nullptr*;
11836	}
11837	const tflite::ExpandDimsOptions builtin_options_as_ExpandDimsOptions() const* {
11838	return builtin_options_type() == tflite::BuiltinOptions_ExpandDimsOptions ? static_cast<const tflite::ExpandDimsOptions >(builtin_options()) : nullptr*;
11839	}
11840	const tflite::EqualOptions builtin_options_as_EqualOptions() const* {
11841	return builtin_options_type() == tflite::BuiltinOptions_EqualOptions ? static_cast<const tflite::EqualOptions >(builtin_options()) : nullptr*;
11842	}
11843	const tflite::NotEqualOptions builtin_options_as_NotEqualOptions() const* {
11844	return builtin_options_type() == tflite::BuiltinOptions_NotEqualOptions ? static_cast<const tflite::NotEqualOptions >(builtin_options()) : nullptr*;
11845	}
11846	const tflite::ShapeOptions builtin_options_as_ShapeOptions() const* {
11847	return builtin_options_type() == tflite::BuiltinOptions_ShapeOptions ? static_cast<const tflite::ShapeOptions >(builtin_options()) : nullptr*;
11848	}
11849	const tflite::PowOptions builtin_options_as_PowOptions() const* {
11850	return builtin_options_type() == tflite::BuiltinOptions_PowOptions ? static_cast<const tflite::PowOptions >(builtin_options()) : nullptr*;
11851	}
11852	const tflite::ArgMinOptions builtin_options_as_ArgMinOptions() const* {
11853	return builtin_options_type() == tflite::BuiltinOptions_ArgMinOptions ? static_cast<const tflite::ArgMinOptions >(builtin_options()) : nullptr*;
11854	}
11855	const tflite::FakeQuantOptions builtin_options_as_FakeQuantOptions() const* {
11856	return builtin_options_type() == tflite::BuiltinOptions_FakeQuantOptions ? static_cast<const tflite::FakeQuantOptions >(builtin_options()) : nullptr*;
11857	}
11858	const tflite::PackOptions builtin_options_as_PackOptions() const* {
11859	return builtin_options_type() == tflite::BuiltinOptions_PackOptions ? static_cast<const tflite::PackOptions >(builtin_options()) : nullptr*;
11860	}
11861	const tflite::LogicalOrOptions builtin_options_as_LogicalOrOptions() const* {
11862	return builtin_options_type() == tflite::BuiltinOptions_LogicalOrOptions ? static_cast<const tflite::LogicalOrOptions >(builtin_options()) : nullptr*;
11863	}
11864	const tflite::OneHotOptions builtin_options_as_OneHotOptions() const* {
11865	return builtin_options_type() == tflite::BuiltinOptions_OneHotOptions ? static_cast<const tflite::OneHotOptions >(builtin_options()) : nullptr*;
11866	}
11867	const tflite::LogicalAndOptions builtin_options_as_LogicalAndOptions() const* {
11868	return builtin_options_type() == tflite::BuiltinOptions_LogicalAndOptions ? static_cast<const tflite::LogicalAndOptions >(builtin_options()) : nullptr*;
11869	}
11870	const tflite::LogicalNotOptions builtin_options_as_LogicalNotOptions() const* {
11871	return builtin_options_type() == tflite::BuiltinOptions_LogicalNotOptions ? static_cast<const tflite::LogicalNotOptions >(builtin_options()) : nullptr*;
11872	}
11873	const tflite::UnpackOptions builtin_options_as_UnpackOptions() const* {
11874	return builtin_options_type() == tflite::BuiltinOptions_UnpackOptions ? static_cast<const tflite::UnpackOptions >(builtin_options()) : nullptr*;
11875	}
11876	const tflite::FloorDivOptions builtin_options_as_FloorDivOptions() const* {
11877	return builtin_options_type() == tflite::BuiltinOptions_FloorDivOptions ? static_cast<const tflite::FloorDivOptions >(builtin_options()) : nullptr*;
11878	}
11879	const tflite::SquareOptions builtin_options_as_SquareOptions() const* {
11880	return builtin_options_type() == tflite::BuiltinOptions_SquareOptions ? static_cast<const tflite::SquareOptions >(builtin_options()) : nullptr*;
11881	}
11882	const tflite::ZerosLikeOptions builtin_options_as_ZerosLikeOptions() const* {
11883	return builtin_options_type() == tflite::BuiltinOptions_ZerosLikeOptions ? static_cast<const tflite::ZerosLikeOptions >(builtin_options()) : nullptr*;
11884	}
11885	const tflite::FillOptions builtin_options_as_FillOptions() const* {
11886	return builtin_options_type() == tflite::BuiltinOptions_FillOptions ? static_cast<const tflite::FillOptions >(builtin_options()) : nullptr*;
11887	}
11888	const tflite::BidirectionalSequenceLSTMOptions builtin_options_as_BidirectionalSequenceLSTMOptions() const* {
11889	return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const tflite::BidirectionalSequenceLSTMOptions >(builtin_options()) : nullptr*;
11890	}
11891	const tflite::BidirectionalSequenceRNNOptions builtin_options_as_BidirectionalSequenceRNNOptions() const* {
11892	return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const tflite::BidirectionalSequenceRNNOptions >(builtin_options()) : nullptr*;
11893	}
11894	const tflite::UnidirectionalSequenceLSTMOptions builtin_options_as_UnidirectionalSequenceLSTMOptions() const* {
11895	return builtin_options_type() == tflite::BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const tflite::UnidirectionalSequenceLSTMOptions >(builtin_options()) : nullptr*;
11896	}
11897	const tflite::FloorModOptions builtin_options_as_FloorModOptions() const* {
11898	return builtin_options_type() == tflite::BuiltinOptions_FloorModOptions ? static_cast<const tflite::FloorModOptions >(builtin_options()) : nullptr*;
11899	}
11900	const tflite::RangeOptions builtin_options_as_RangeOptions() const* {
11901	return builtin_options_type() == tflite::BuiltinOptions_RangeOptions ? static_cast<const tflite::RangeOptions >(builtin_options()) : nullptr*;
11902	}
11903	const tflite::ResizeNearestNeighborOptions builtin_options_as_ResizeNearestNeighborOptions() const* {
11904	return builtin_options_type() == tflite::BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const tflite::ResizeNearestNeighborOptions >(builtin_options()) : nullptr*;
11905	}
11906	const tflite::LeakyReluOptions builtin_options_as_LeakyReluOptions() const* {
11907	return builtin_options_type() == tflite::BuiltinOptions_LeakyReluOptions ? static_cast<const tflite::LeakyReluOptions >(builtin_options()) : nullptr*;
11908	}
11909	const tflite::SquaredDifferenceOptions builtin_options_as_SquaredDifferenceOptions() const* {
11910	return builtin_options_type() == tflite::BuiltinOptions_SquaredDifferenceOptions ? static_cast<const tflite::SquaredDifferenceOptions >(builtin_options()) : nullptr*;
11911	}
11912	const tflite::MirrorPadOptions builtin_options_as_MirrorPadOptions() const* {
11913	return builtin_options_type() == tflite::BuiltinOptions_MirrorPadOptions ? static_cast<const tflite::MirrorPadOptions >(builtin_options()) : nullptr*;
11914	}
11915	const tflite::AbsOptions builtin_options_as_AbsOptions() const* {
11916	return builtin_options_type() == tflite::BuiltinOptions_AbsOptions ? static_cast<const tflite::AbsOptions >(builtin_options()) : nullptr*;
11917	}
11918	const tflite::SplitVOptions builtin_options_as_SplitVOptions() const* {
11919	return builtin_options_type() == tflite::BuiltinOptions_SplitVOptions ? static_cast<const tflite::SplitVOptions >(builtin_options()) : nullptr*;
11920	}
11921	const tflite::UniqueOptions builtin_options_as_UniqueOptions() const* {
11922	return builtin_options_type() == tflite::BuiltinOptions_UniqueOptions ? static_cast<const tflite::UniqueOptions >(builtin_options()) : nullptr*;
11923	}
11924	const tflite::ReverseV2Options builtin_options_as_ReverseV2Options() const* {
11925	return builtin_options_type() == tflite::BuiltinOptions_ReverseV2Options ? static_cast<const tflite::ReverseV2Options >(builtin_options()) : nullptr*;
11926	}
11927	const tflite::AddNOptions builtin_options_as_AddNOptions() const* {
11928	return builtin_options_type() == tflite::BuiltinOptions_AddNOptions ? static_cast<const tflite::AddNOptions >(builtin_options()) : nullptr*;
11929	}
11930	const tflite::GatherNdOptions builtin_options_as_GatherNdOptions() const* {
11931	return builtin_options_type() == tflite::BuiltinOptions_GatherNdOptions ? static_cast<const tflite::GatherNdOptions >(builtin_options()) : nullptr*;
11932	}
11933	const tflite::CosOptions builtin_options_as_CosOptions() const* {
11934	return builtin_options_type() == tflite::BuiltinOptions_CosOptions ? static_cast<const tflite::CosOptions >(builtin_options()) : nullptr*;
11935	}
11936	const tflite::WhereOptions builtin_options_as_WhereOptions() const* {
11937	return builtin_options_type() == tflite::BuiltinOptions_WhereOptions ? static_cast<const tflite::WhereOptions >(builtin_options()) : nullptr*;
11938	}
11939	const tflite::RankOptions builtin_options_as_RankOptions() const* {
11940	return builtin_options_type() == tflite::BuiltinOptions_RankOptions ? static_cast<const tflite::RankOptions >(builtin_options()) : nullptr*;
11941	}
11942	const tflite::ReverseSequenceOptions builtin_options_as_ReverseSequenceOptions() const* {
11943	return builtin_options_type() == tflite::BuiltinOptions_ReverseSequenceOptions ? static_cast<const tflite::ReverseSequenceOptions >(builtin_options()) : nullptr*;
11944	}
11945	const tflite::MatrixDiagOptions builtin_options_as_MatrixDiagOptions() const* {
11946	return builtin_options_type() == tflite::BuiltinOptions_MatrixDiagOptions ? static_cast<const tflite::MatrixDiagOptions >(builtin_options()) : nullptr*;
11947	}
11948	const tflite::QuantizeOptions builtin_options_as_QuantizeOptions() const* {
11949	return builtin_options_type() == tflite::BuiltinOptions_QuantizeOptions ? static_cast<const tflite::QuantizeOptions >(builtin_options()) : nullptr*;
11950	}
11951	const tflite::MatrixSetDiagOptions builtin_options_as_MatrixSetDiagOptions() const* {
11952	return builtin_options_type() == tflite::BuiltinOptions_MatrixSetDiagOptions ? static_cast<const tflite::MatrixSetDiagOptions >(builtin_options()) : nullptr*;
11953	}
11954	const tflite::HardSwishOptions builtin_options_as_HardSwishOptions() const* {
11955	return builtin_options_type() == tflite::BuiltinOptions_HardSwishOptions ? static_cast<const tflite::HardSwishOptions >(builtin_options()) : nullptr*;
11956	}
11957	const tflite::IfOptions builtin_options_as_IfOptions() const* {
11958	return builtin_options_type() == tflite::BuiltinOptions_IfOptions ? static_cast<const tflite::IfOptions >(builtin_options()) : nullptr*;
11959	}
11960	const tflite::WhileOptions builtin_options_as_WhileOptions() const* {
11961	return builtin_options_type() == tflite::BuiltinOptions_WhileOptions ? static_cast<const tflite::WhileOptions >(builtin_options()) : nullptr*;
11962	}
11963	const tflite::DepthToSpaceOptions builtin_options_as_DepthToSpaceOptions() const* {
11964	return builtin_options_type() == tflite::BuiltinOptions_DepthToSpaceOptions ? static_cast<const tflite::DepthToSpaceOptions >(builtin_options()) : nullptr*;
11965	}
11966	const tflite::NonMaxSuppressionV4Options builtin_options_as_NonMaxSuppressionV4Options() const* {
11967	return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV4Options ? static_cast<const tflite::NonMaxSuppressionV4Options >(builtin_options()) : nullptr*;
11968	}
11969	const tflite::NonMaxSuppressionV5Options builtin_options_as_NonMaxSuppressionV5Options() const* {
11970	return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV5Options ? static_cast<const tflite::NonMaxSuppressionV5Options >(builtin_options()) : nullptr*;
11971	}
11972	const tflite::ScatterNdOptions builtin_options_as_ScatterNdOptions() const* {
11973	return builtin_options_type() == tflite::BuiltinOptions_ScatterNdOptions ? static_cast<const tflite::ScatterNdOptions >(builtin_options()) : nullptr*;
11974	}
11975	const tflite::SelectV2Options builtin_options_as_SelectV2Options() const* {
11976	return builtin_options_type() == tflite::BuiltinOptions_SelectV2Options ? static_cast<const tflite::SelectV2Options >(builtin_options()) : nullptr*;
11977	}
11978	const tflite::DensifyOptions builtin_options_as_DensifyOptions() const* {
11979	return builtin_options_type() == tflite::BuiltinOptions_DensifyOptions ? static_cast<const tflite::DensifyOptions >(builtin_options()) : nullptr*;
11980	}
11981	const tflite::SegmentSumOptions builtin_options_as_SegmentSumOptions() const* {
11982	return builtin_options_type() == tflite::BuiltinOptions_SegmentSumOptions ? static_cast<const tflite::SegmentSumOptions >(builtin_options()) : nullptr*;
11983	}
11984	const tflite::BatchMatMulOptions builtin_options_as_BatchMatMulOptions() const* {
11985	return builtin_options_type() == tflite::BuiltinOptions_BatchMatMulOptions ? static_cast<const tflite::BatchMatMulOptions >(builtin_options()) : nullptr*;
11986	}
11987	const tflite::CumsumOptions builtin_options_as_CumsumOptions() const* {
11988	return builtin_options_type() == tflite::BuiltinOptions_CumsumOptions ? static_cast<const tflite::CumsumOptions >(builtin_options()) : nullptr*;
11989	}
11990	const tflite::CallOnceOptions builtin_options_as_CallOnceOptions() const* {
11991	return builtin_options_type() == tflite::BuiltinOptions_CallOnceOptions ? static_cast<const tflite::CallOnceOptions >(builtin_options()) : nullptr*;
11992	}
11993	const tflite::BroadcastToOptions builtin_options_as_BroadcastToOptions() const* {
11994	return builtin_options_type() == tflite::BuiltinOptions_BroadcastToOptions ? static_cast<const tflite::BroadcastToOptions >(builtin_options()) : nullptr*;
11995	}
11996	const tflite::Rfft2dOptions builtin_options_as_Rfft2dOptions() const* {
11997	return builtin_options_type() == tflite::BuiltinOptions_Rfft2dOptions ? static_cast<const tflite::Rfft2dOptions >(builtin_options()) : nullptr*;
11998	}
11999	const tflite::Conv3DOptions builtin_options_as_Conv3DOptions() const* {
12000	return builtin_options_type() == tflite::BuiltinOptions_Conv3DOptions ? static_cast<const tflite::Conv3DOptions >(builtin_options()) : nullptr*;
12001	}
12002	const tflite::HashtableOptions builtin_options_as_HashtableOptions() const* {
12003	return builtin_options_type() == tflite::BuiltinOptions_HashtableOptions ? static_cast<const tflite::HashtableOptions >(builtin_options()) : nullptr*;
12004	}
12005	const tflite::HashtableFindOptions builtin_options_as_HashtableFindOptions() const* {
12006	return builtin_options_type() == tflite::BuiltinOptions_HashtableFindOptions ? static_cast<const tflite::HashtableFindOptions >(builtin_options()) : nullptr*;
12007	}
12008	const tflite::HashtableImportOptions builtin_options_as_HashtableImportOptions() const* {
12009	return builtin_options_type() == tflite::BuiltinOptions_HashtableImportOptions ? static_cast<const tflite::HashtableImportOptions >(builtin_options()) : nullptr*;
12010	}
12011	const tflite::HashtableSizeOptions builtin_options_as_HashtableSizeOptions() const* {
12012	return builtin_options_type() == tflite::BuiltinOptions_HashtableSizeOptions ? static_cast<const tflite::HashtableSizeOptions >(builtin_options()) : nullptr*;
12013	}
12014	const tflite::VarHandleOptions builtin_options_as_VarHandleOptions() const* {
12015	return builtin_options_type() == tflite::BuiltinOptions_VarHandleOptions ? static_cast<const tflite::VarHandleOptions >(builtin_options()) : nullptr*;
12016	}
12017	const tflite::ReadVariableOptions builtin_options_as_ReadVariableOptions() const* {
12018	return builtin_options_type() == tflite::BuiltinOptions_ReadVariableOptions ? static_cast<const tflite::ReadVariableOptions >(builtin_options()) : nullptr*;
12019	}
12020	const tflite::AssignVariableOptions builtin_options_as_AssignVariableOptions() const* {
12021	return builtin_options_type() == tflite::BuiltinOptions_AssignVariableOptions ? static_cast<const tflite::AssignVariableOptions >(builtin_options()) : nullptr*;
12022	}
12023	const tflite::RandomOptions builtin_options_as_RandomOptions() const* {
12024	return builtin_options_type() == tflite::BuiltinOptions_RandomOptions ? static_cast<const tflite::RandomOptions >(builtin_options()) : nullptr*;
12025	}
12026	const tflite::BucketizeOptions builtin_options_as_BucketizeOptions() const* {
12027	return builtin_options_type() == tflite::BuiltinOptions_BucketizeOptions ? static_cast<const tflite::BucketizeOptions >(builtin_options()) : nullptr*;
12028	}
12029	const tflite::GeluOptions builtin_options_as_GeluOptions() const* {
12030	return builtin_options_type() == tflite::BuiltinOptions_GeluOptions ? static_cast<const tflite::GeluOptions >(builtin_options()) : nullptr*;
12031	}
12032	const tflite::DynamicUpdateSliceOptions builtin_options_as_DynamicUpdateSliceOptions() const* {
12033	return builtin_options_type() == tflite::BuiltinOptions_DynamicUpdateSliceOptions ? static_cast<const tflite::DynamicUpdateSliceOptions >(builtin_options()) : nullptr*;
12034	}
12035	const tflite::UnsortedSegmentProdOptions builtin_options_as_UnsortedSegmentProdOptions() const* {
12036	return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentProdOptions ? static_cast<const tflite::UnsortedSegmentProdOptions >(builtin_options()) : nullptr*;
12037	}
12038	const tflite::UnsortedSegmentMaxOptions builtin_options_as_UnsortedSegmentMaxOptions() const* {
12039	return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentMaxOptions ? static_cast<const tflite::UnsortedSegmentMaxOptions >(builtin_options()) : nullptr*;
12040	}
12041	const tflite::UnsortedSegmentMinOptions builtin_options_as_UnsortedSegmentMinOptions() const* {
12042	return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentMinOptions ? static_cast<const tflite::UnsortedSegmentMinOptions >(builtin_options()) : nullptr*;
12043	}
12044	const tflite::UnsortedSegmentSumOptions builtin_options_as_UnsortedSegmentSumOptions() const* {
12045	return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentSumOptions ? static_cast<const tflite::UnsortedSegmentSumOptions >(builtin_options()) : nullptr*;
12046	}
12047	const tflite::ATan2Options builtin_options_as_ATan2Options() const* {
12048	return builtin_options_type() == tflite::BuiltinOptions_ATan2Options ? static_cast<const tflite::ATan2Options >(builtin_options()) : nullptr*;
12049	}
12050	const tflite::SignOptions builtin_options_as_SignOptions() const* {
12051	return builtin_options_type() == tflite::BuiltinOptions_SignOptions ? static_cast<const tflite::SignOptions >(builtin_options()) : nullptr*;
12052	}
12053	const flatbuffers::Vector<uint8_t> custom_options() const* {
12054	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
12055	}
12056	tflite::CustomOptionsFormat custom_options_format() const {
12057	return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, `0`));
12058	}
12059	const flatbuffers::Vector<uint8_t> mutating_variable_inputs() const* {
12060	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
12061	}
12062	const flatbuffers::Vector<int32_t> intermediates() const* {
12063	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
12064	}
12065	bool Verify(flatbuffers::Verifier &verifier) const {
12066	return VerifyTableStart(verifier) &&
12067	VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX, `4`) &&
12068	VerifyOffset(verifier, VT_INPUTS) &&
12069	verifier.VerifyVector(inputs()) &&
12070	VerifyOffset(verifier, VT_OUTPUTS) &&
12071	verifier.VerifyVector(outputs()) &&
12072	VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE, `1`) &&
12073	VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
12074	VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
12075	VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
12076	verifier.VerifyVector(custom_options()) &&
12077	VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT, `1`) &&
12078	VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
12079	verifier.VerifyVector(mutating_variable_inputs()) &&
12080	VerifyOffset(verifier, VT_INTERMEDIATES) &&
12081	verifier.VerifyVector(intermediates()) &&
12082	verifier.EndTable();
12083	}
12084	OperatorT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12085	void UnPackTo(OperatorT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12086	static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
12087	};
12088
12089	template<> inline const tflite::Conv2DOptions Operator::builtin_options_as<tflite::Conv2DOptions>() const* {
12090	return builtin_options_as_Conv2DOptions();
12091	}
12092
12093	template<> inline const tflite::DepthwiseConv2DOptions Operator::builtin_options_as<tflite::DepthwiseConv2DOptions>() const* {
12094	return builtin_options_as_DepthwiseConv2DOptions();
12095	}
12096
12097	template<> inline const tflite::ConcatEmbeddingsOptions Operator::builtin_options_as<tflite::ConcatEmbeddingsOptions>() const* {
12098	return builtin_options_as_ConcatEmbeddingsOptions();
12099	}
12100
12101	template<> inline const tflite::LSHProjectionOptions Operator::builtin_options_as<tflite::LSHProjectionOptions>() const* {
12102	return builtin_options_as_LSHProjectionOptions();
12103	}
12104
12105	template<> inline const tflite::Pool2DOptions Operator::builtin_options_as<tflite::Pool2DOptions>() const* {
12106	return builtin_options_as_Pool2DOptions();
12107	}
12108
12109	template<> inline const tflite::SVDFOptions Operator::builtin_options_as<tflite::SVDFOptions>() const* {
12110	return builtin_options_as_SVDFOptions();
12111	}
12112
12113	template<> inline const tflite::RNNOptions Operator::builtin_options_as<tflite::RNNOptions>() const* {
12114	return builtin_options_as_RNNOptions();
12115	}
12116
12117	template<> inline const tflite::FullyConnectedOptions Operator::builtin_options_as<tflite::FullyConnectedOptions>() const* {
12118	return builtin_options_as_FullyConnectedOptions();
12119	}
12120
12121	template<> inline const tflite::SoftmaxOptions Operator::builtin_options_as<tflite::SoftmaxOptions>() const* {
12122	return builtin_options_as_SoftmaxOptions();
12123	}
12124
12125	template<> inline const tflite::ConcatenationOptions Operator::builtin_options_as<tflite::ConcatenationOptions>() const* {
12126	return builtin_options_as_ConcatenationOptions();
12127	}
12128
12129	template<> inline const tflite::AddOptions Operator::builtin_options_as<tflite::AddOptions>() const* {
12130	return builtin_options_as_AddOptions();
12131	}
12132
12133	template<> inline const tflite::L2NormOptions Operator::builtin_options_as<tflite::L2NormOptions>() const* {
12134	return builtin_options_as_L2NormOptions();
12135	}
12136
12137	template<> inline const tflite::LocalResponseNormalizationOptions Operator::builtin_options_as<tflite::LocalResponseNormalizationOptions>() const* {
12138	return builtin_options_as_LocalResponseNormalizationOptions();
12139	}
12140
12141	template<> inline const tflite::LSTMOptions Operator::builtin_options_as<tflite::LSTMOptions>() const* {
12142	return builtin_options_as_LSTMOptions();
12143	}
12144
12145	template<> inline const tflite::ResizeBilinearOptions Operator::builtin_options_as<tflite::ResizeBilinearOptions>() const* {
12146	return builtin_options_as_ResizeBilinearOptions();
12147	}
12148
12149	template<> inline const tflite::CallOptions Operator::builtin_options_as<tflite::CallOptions>() const* {
12150	return builtin_options_as_CallOptions();
12151	}
12152
12153	template<> inline const tflite::ReshapeOptions Operator::builtin_options_as<tflite::ReshapeOptions>() const* {
12154	return builtin_options_as_ReshapeOptions();
12155	}
12156
12157	template<> inline const tflite::SkipGramOptions Operator::builtin_options_as<tflite::SkipGramOptions>() const* {
12158	return builtin_options_as_SkipGramOptions();
12159	}
12160
12161	template<> inline const tflite::SpaceToDepthOptions Operator::builtin_options_as<tflite::SpaceToDepthOptions>() const* {
12162	return builtin_options_as_SpaceToDepthOptions();
12163	}
12164
12165	template<> inline const tflite::EmbeddingLookupSparseOptions Operator::builtin_options_as<tflite::EmbeddingLookupSparseOptions>() const* {
12166	return builtin_options_as_EmbeddingLookupSparseOptions();
12167	}
12168
12169	template<> inline const tflite::MulOptions Operator::builtin_options_as<tflite::MulOptions>() const* {
12170	return builtin_options_as_MulOptions();
12171	}
12172
12173	template<> inline const tflite::PadOptions Operator::builtin_options_as<tflite::PadOptions>() const* {
12174	return builtin_options_as_PadOptions();
12175	}
12176
12177	template<> inline const tflite::GatherOptions Operator::builtin_options_as<tflite::GatherOptions>() const* {
12178	return builtin_options_as_GatherOptions();
12179	}
12180
12181	template<> inline const tflite::BatchToSpaceNDOptions Operator::builtin_options_as<tflite::BatchToSpaceNDOptions>() const* {
12182	return builtin_options_as_BatchToSpaceNDOptions();
12183	}
12184
12185	template<> inline const tflite::SpaceToBatchNDOptions Operator::builtin_options_as<tflite::SpaceToBatchNDOptions>() const* {
12186	return builtin_options_as_SpaceToBatchNDOptions();
12187	}
12188
12189	template<> inline const tflite::TransposeOptions Operator::builtin_options_as<tflite::TransposeOptions>() const* {
12190	return builtin_options_as_TransposeOptions();
12191	}
12192
12193	template<> inline const tflite::ReducerOptions Operator::builtin_options_as<tflite::ReducerOptions>() const* {
12194	return builtin_options_as_ReducerOptions();
12195	}
12196
12197	template<> inline const tflite::SubOptions Operator::builtin_options_as<tflite::SubOptions>() const* {
12198	return builtin_options_as_SubOptions();
12199	}
12200
12201	template<> inline const tflite::DivOptions Operator::builtin_options_as<tflite::DivOptions>() const* {
12202	return builtin_options_as_DivOptions();
12203	}
12204
12205	template<> inline const tflite::SqueezeOptions Operator::builtin_options_as<tflite::SqueezeOptions>() const* {
12206	return builtin_options_as_SqueezeOptions();
12207	}
12208
12209	template<> inline const tflite::SequenceRNNOptions Operator::builtin_options_as<tflite::SequenceRNNOptions>() const* {
12210	return builtin_options_as_SequenceRNNOptions();
12211	}
12212
12213	template<> inline const tflite::StridedSliceOptions Operator::builtin_options_as<tflite::StridedSliceOptions>() const* {
12214	return builtin_options_as_StridedSliceOptions();
12215	}
12216
12217	template<> inline const tflite::ExpOptions Operator::builtin_options_as<tflite::ExpOptions>() const* {
12218	return builtin_options_as_ExpOptions();
12219	}
12220
12221	template<> inline const tflite::TopKV2Options Operator::builtin_options_as<tflite::TopKV2Options>() const* {
12222	return builtin_options_as_TopKV2Options();
12223	}
12224
12225	template<> inline const tflite::SplitOptions Operator::builtin_options_as<tflite::SplitOptions>() const* {
12226	return builtin_options_as_SplitOptions();
12227	}
12228
12229	template<> inline const tflite::LogSoftmaxOptions Operator::builtin_options_as<tflite::LogSoftmaxOptions>() const* {
12230	return builtin_options_as_LogSoftmaxOptions();
12231	}
12232
12233	template<> inline const tflite::CastOptions Operator::builtin_options_as<tflite::CastOptions>() const* {
12234	return builtin_options_as_CastOptions();
12235	}
12236
12237	template<> inline const tflite::DequantizeOptions Operator::builtin_options_as<tflite::DequantizeOptions>() const* {
12238	return builtin_options_as_DequantizeOptions();
12239	}
12240
12241	template<> inline const tflite::MaximumMinimumOptions Operator::builtin_options_as<tflite::MaximumMinimumOptions>() const* {
12242	return builtin_options_as_MaximumMinimumOptions();
12243	}
12244
12245	template<> inline const tflite::ArgMaxOptions Operator::builtin_options_as<tflite::ArgMaxOptions>() const* {
12246	return builtin_options_as_ArgMaxOptions();
12247	}
12248
12249	template<> inline const tflite::LessOptions Operator::builtin_options_as<tflite::LessOptions>() const* {
12250	return builtin_options_as_LessOptions();
12251	}
12252
12253	template<> inline const tflite::NegOptions Operator::builtin_options_as<tflite::NegOptions>() const* {
12254	return builtin_options_as_NegOptions();
12255	}
12256
12257	template<> inline const tflite::PadV2Options Operator::builtin_options_as<tflite::PadV2Options>() const* {
12258	return builtin_options_as_PadV2Options();
12259	}
12260
12261	template<> inline const tflite::GreaterOptions Operator::builtin_options_as<tflite::GreaterOptions>() const* {
12262	return builtin_options_as_GreaterOptions();
12263	}
12264
12265	template<> inline const tflite::GreaterEqualOptions Operator::builtin_options_as<tflite::GreaterEqualOptions>() const* {
12266	return builtin_options_as_GreaterEqualOptions();
12267	}
12268
12269	template<> inline const tflite::LessEqualOptions Operator::builtin_options_as<tflite::LessEqualOptions>() const* {
12270	return builtin_options_as_LessEqualOptions();
12271	}
12272
12273	template<> inline const tflite::SelectOptions Operator::builtin_options_as<tflite::SelectOptions>() const* {
12274	return builtin_options_as_SelectOptions();
12275	}
12276
12277	template<> inline const tflite::SliceOptions Operator::builtin_options_as<tflite::SliceOptions>() const* {
12278	return builtin_options_as_SliceOptions();
12279	}
12280
12281	template<> inline const tflite::TransposeConvOptions Operator::builtin_options_as<tflite::TransposeConvOptions>() const* {
12282	return builtin_options_as_TransposeConvOptions();
12283	}
12284
12285	template<> inline const tflite::SparseToDenseOptions Operator::builtin_options_as<tflite::SparseToDenseOptions>() const* {
12286	return builtin_options_as_SparseToDenseOptions();
12287	}
12288
12289	template<> inline const tflite::TileOptions Operator::builtin_options_as<tflite::TileOptions>() const* {
12290	return builtin_options_as_TileOptions();
12291	}
12292
12293	template<> inline const tflite::ExpandDimsOptions Operator::builtin_options_as<tflite::ExpandDimsOptions>() const* {
12294	return builtin_options_as_ExpandDimsOptions();
12295	}
12296
12297	template<> inline const tflite::EqualOptions Operator::builtin_options_as<tflite::EqualOptions>() const* {
12298	return builtin_options_as_EqualOptions();
12299	}
12300
12301	template<> inline const tflite::NotEqualOptions Operator::builtin_options_as<tflite::NotEqualOptions>() const* {
12302	return builtin_options_as_NotEqualOptions();
12303	}
12304
12305	template<> inline const tflite::ShapeOptions Operator::builtin_options_as<tflite::ShapeOptions>() const* {
12306	return builtin_options_as_ShapeOptions();
12307	}
12308
12309	template<> inline const tflite::PowOptions Operator::builtin_options_as<tflite::PowOptions>() const* {
12310	return builtin_options_as_PowOptions();
12311	}
12312
12313	template<> inline const tflite::ArgMinOptions Operator::builtin_options_as<tflite::ArgMinOptions>() const* {
12314	return builtin_options_as_ArgMinOptions();
12315	}
12316
12317	template<> inline const tflite::FakeQuantOptions Operator::builtin_options_as<tflite::FakeQuantOptions>() const* {
12318	return builtin_options_as_FakeQuantOptions();
12319	}
12320
12321	template<> inline const tflite::PackOptions Operator::builtin_options_as<tflite::PackOptions>() const* {
12322	return builtin_options_as_PackOptions();
12323	}
12324
12325	template<> inline const tflite::LogicalOrOptions Operator::builtin_options_as<tflite::LogicalOrOptions>() const* {
12326	return builtin_options_as_LogicalOrOptions();
12327	}
12328
12329	template<> inline const tflite::OneHotOptions Operator::builtin_options_as<tflite::OneHotOptions>() const* {
12330	return builtin_options_as_OneHotOptions();
12331	}
12332
12333	template<> inline const tflite::LogicalAndOptions Operator::builtin_options_as<tflite::LogicalAndOptions>() const* {
12334	return builtin_options_as_LogicalAndOptions();
12335	}
12336
12337	template<> inline const tflite::LogicalNotOptions Operator::builtin_options_as<tflite::LogicalNotOptions>() const* {
12338	return builtin_options_as_LogicalNotOptions();
12339	}
12340
12341	template<> inline const tflite::UnpackOptions Operator::builtin_options_as<tflite::UnpackOptions>() const* {
12342	return builtin_options_as_UnpackOptions();
12343	}
12344
12345	template<> inline const tflite::FloorDivOptions Operator::builtin_options_as<tflite::FloorDivOptions>() const* {
12346	return builtin_options_as_FloorDivOptions();
12347	}
12348
12349	template<> inline const tflite::SquareOptions Operator::builtin_options_as<tflite::SquareOptions>() const* {
12350	return builtin_options_as_SquareOptions();
12351	}
12352
12353	template<> inline const tflite::ZerosLikeOptions Operator::builtin_options_as<tflite::ZerosLikeOptions>() const* {
12354	return builtin_options_as_ZerosLikeOptions();
12355	}
12356
12357	template<> inline const tflite::FillOptions Operator::builtin_options_as<tflite::FillOptions>() const* {
12358	return builtin_options_as_FillOptions();
12359	}
12360
12361	template<> inline const tflite::BidirectionalSequenceLSTMOptions Operator::builtin_options_as<tflite::BidirectionalSequenceLSTMOptions>() const* {
12362	return builtin_options_as_BidirectionalSequenceLSTMOptions();
12363	}
12364
12365	template<> inline const tflite::BidirectionalSequenceRNNOptions Operator::builtin_options_as<tflite::BidirectionalSequenceRNNOptions>() const* {
12366	return builtin_options_as_BidirectionalSequenceRNNOptions();
12367	}
12368
12369	template<> inline const tflite::UnidirectionalSequenceLSTMOptions Operator::builtin_options_as<tflite::UnidirectionalSequenceLSTMOptions>() const* {
12370	return builtin_options_as_UnidirectionalSequenceLSTMOptions();
12371	}
12372
12373	template<> inline const tflite::FloorModOptions Operator::builtin_options_as<tflite::FloorModOptions>() const* {
12374	return builtin_options_as_FloorModOptions();
12375	}
12376
12377	template<> inline const tflite::RangeOptions Operator::builtin_options_as<tflite::RangeOptions>() const* {
12378	return builtin_options_as_RangeOptions();
12379	}
12380
12381	template<> inline const tflite::ResizeNearestNeighborOptions Operator::builtin_options_as<tflite::ResizeNearestNeighborOptions>() const* {
12382	return builtin_options_as_ResizeNearestNeighborOptions();
12383	}
12384
12385	template<> inline const tflite::LeakyReluOptions Operator::builtin_options_as<tflite::LeakyReluOptions>() const* {
12386	return builtin_options_as_LeakyReluOptions();
12387	}
12388
12389	template<> inline const tflite::SquaredDifferenceOptions Operator::builtin_options_as<tflite::SquaredDifferenceOptions>() const* {
12390	return builtin_options_as_SquaredDifferenceOptions();
12391	}
12392
12393	template<> inline const tflite::MirrorPadOptions Operator::builtin_options_as<tflite::MirrorPadOptions>() const* {
12394	return builtin_options_as_MirrorPadOptions();
12395	}
12396
12397	template<> inline const tflite::AbsOptions Operator::builtin_options_as<tflite::AbsOptions>() const* {
12398	return builtin_options_as_AbsOptions();
12399	}
12400
12401	template<> inline const tflite::SplitVOptions Operator::builtin_options_as<tflite::SplitVOptions>() const* {
12402	return builtin_options_as_SplitVOptions();
12403	}
12404
12405	template<> inline const tflite::UniqueOptions Operator::builtin_options_as<tflite::UniqueOptions>() const* {
12406	return builtin_options_as_UniqueOptions();
12407	}
12408
12409	template<> inline const tflite::ReverseV2Options Operator::builtin_options_as<tflite::ReverseV2Options>() const* {
12410	return builtin_options_as_ReverseV2Options();
12411	}
12412
12413	template<> inline const tflite::AddNOptions Operator::builtin_options_as<tflite::AddNOptions>() const* {
12414	return builtin_options_as_AddNOptions();
12415	}
12416
12417	template<> inline const tflite::GatherNdOptions Operator::builtin_options_as<tflite::GatherNdOptions>() const* {
12418	return builtin_options_as_GatherNdOptions();
12419	}
12420
12421	template<> inline const tflite::CosOptions Operator::builtin_options_as<tflite::CosOptions>() const* {
12422	return builtin_options_as_CosOptions();
12423	}
12424
12425	template<> inline const tflite::WhereOptions Operator::builtin_options_as<tflite::WhereOptions>() const* {
12426	return builtin_options_as_WhereOptions();
12427	}
12428
12429	template<> inline const tflite::RankOptions Operator::builtin_options_as<tflite::RankOptions>() const* {
12430	return builtin_options_as_RankOptions();
12431	}
12432
12433	template<> inline const tflite::ReverseSequenceOptions Operator::builtin_options_as<tflite::ReverseSequenceOptions>() const* {
12434	return builtin_options_as_ReverseSequenceOptions();
12435	}
12436
12437	template<> inline const tflite::MatrixDiagOptions Operator::builtin_options_as<tflite::MatrixDiagOptions>() const* {
12438	return builtin_options_as_MatrixDiagOptions();
12439	}
12440
12441	template<> inline const tflite::QuantizeOptions Operator::builtin_options_as<tflite::QuantizeOptions>() const* {
12442	return builtin_options_as_QuantizeOptions();
12443	}
12444
12445	template<> inline const tflite::MatrixSetDiagOptions Operator::builtin_options_as<tflite::MatrixSetDiagOptions>() const* {
12446	return builtin_options_as_MatrixSetDiagOptions();
12447	}
12448
12449	template<> inline const tflite::HardSwishOptions Operator::builtin_options_as<tflite::HardSwishOptions>() const* {
12450	return builtin_options_as_HardSwishOptions();
12451	}
12452
12453	template<> inline const tflite::IfOptions Operator::builtin_options_as<tflite::IfOptions>() const* {
12454	return builtin_options_as_IfOptions();
12455	}
12456
12457	template<> inline const tflite::WhileOptions Operator::builtin_options_as<tflite::WhileOptions>() const* {
12458	return builtin_options_as_WhileOptions();
12459	}
12460
12461	template<> inline const tflite::DepthToSpaceOptions Operator::builtin_options_as<tflite::DepthToSpaceOptions>() const* {
12462	return builtin_options_as_DepthToSpaceOptions();
12463	}
12464
12465	template<> inline const tflite::NonMaxSuppressionV4Options Operator::builtin_options_as<tflite::NonMaxSuppressionV4Options>() const* {
12466	return builtin_options_as_NonMaxSuppressionV4Options();
12467	}
12468
12469	template<> inline const tflite::NonMaxSuppressionV5Options Operator::builtin_options_as<tflite::NonMaxSuppressionV5Options>() const* {
12470	return builtin_options_as_NonMaxSuppressionV5Options();
12471	}
12472
12473	template<> inline const tflite::ScatterNdOptions Operator::builtin_options_as<tflite::ScatterNdOptions>() const* {
12474	return builtin_options_as_ScatterNdOptions();
12475	}
12476
12477	template<> inline const tflite::SelectV2Options Operator::builtin_options_as<tflite::SelectV2Options>() const* {
12478	return builtin_options_as_SelectV2Options();
12479	}
12480
12481	template<> inline const tflite::DensifyOptions Operator::builtin_options_as<tflite::DensifyOptions>() const* {
12482	return builtin_options_as_DensifyOptions();
12483	}
12484
12485	template<> inline const tflite::SegmentSumOptions Operator::builtin_options_as<tflite::SegmentSumOptions>() const* {
12486	return builtin_options_as_SegmentSumOptions();
12487	}
12488
12489	template<> inline const tflite::BatchMatMulOptions Operator::builtin_options_as<tflite::BatchMatMulOptions>() const* {
12490	return builtin_options_as_BatchMatMulOptions();
12491	}
12492
12493	template<> inline const tflite::CumsumOptions Operator::builtin_options_as<tflite::CumsumOptions>() const* {
12494	return builtin_options_as_CumsumOptions();
12495	}
12496
12497	template<> inline const tflite::CallOnceOptions Operator::builtin_options_as<tflite::CallOnceOptions>() const* {
12498	return builtin_options_as_CallOnceOptions();
12499	}
12500
12501	template<> inline const tflite::BroadcastToOptions Operator::builtin_options_as<tflite::BroadcastToOptions>() const* {
12502	return builtin_options_as_BroadcastToOptions();
12503	}
12504
12505	template<> inline const tflite::Rfft2dOptions Operator::builtin_options_as<tflite::Rfft2dOptions>() const* {
12506	return builtin_options_as_Rfft2dOptions();
12507	}
12508
12509	template<> inline const tflite::Conv3DOptions Operator::builtin_options_as<tflite::Conv3DOptions>() const* {
12510	return builtin_options_as_Conv3DOptions();
12511	}
12512
12513	template<> inline const tflite::HashtableOptions Operator::builtin_options_as<tflite::HashtableOptions>() const* {
12514	return builtin_options_as_HashtableOptions();
12515	}
12516
12517	template<> inline const tflite::HashtableFindOptions Operator::builtin_options_as<tflite::HashtableFindOptions>() const* {
12518	return builtin_options_as_HashtableFindOptions();
12519	}
12520
12521	template<> inline const tflite::HashtableImportOptions Operator::builtin_options_as<tflite::HashtableImportOptions>() const* {
12522	return builtin_options_as_HashtableImportOptions();
12523	}
12524
12525	template<> inline const tflite::HashtableSizeOptions Operator::builtin_options_as<tflite::HashtableSizeOptions>() const* {
12526	return builtin_options_as_HashtableSizeOptions();
12527	}
12528
12529	template<> inline const tflite::VarHandleOptions Operator::builtin_options_as<tflite::VarHandleOptions>() const* {
12530	return builtin_options_as_VarHandleOptions();
12531	}
12532
12533	template<> inline const tflite::ReadVariableOptions Operator::builtin_options_as<tflite::ReadVariableOptions>() const* {
12534	return builtin_options_as_ReadVariableOptions();
12535	}
12536
12537	template<> inline const tflite::AssignVariableOptions Operator::builtin_options_as<tflite::AssignVariableOptions>() const* {
12538	return builtin_options_as_AssignVariableOptions();
12539	}
12540
12541	template<> inline const tflite::RandomOptions Operator::builtin_options_as<tflite::RandomOptions>() const* {
12542	return builtin_options_as_RandomOptions();
12543	}
12544
12545	template<> inline const tflite::BucketizeOptions Operator::builtin_options_as<tflite::BucketizeOptions>() const* {
12546	return builtin_options_as_BucketizeOptions();
12547	}
12548
12549	template<> inline const tflite::GeluOptions Operator::builtin_options_as<tflite::GeluOptions>() const* {
12550	return builtin_options_as_GeluOptions();
12551	}
12552
12553	template<> inline const tflite::DynamicUpdateSliceOptions Operator::builtin_options_as<tflite::DynamicUpdateSliceOptions>() const* {
12554	return builtin_options_as_DynamicUpdateSliceOptions();
12555	}
12556
12557	template<> inline const tflite::UnsortedSegmentProdOptions Operator::builtin_options_as<tflite::UnsortedSegmentProdOptions>() const* {
12558	return builtin_options_as_UnsortedSegmentProdOptions();
12559	}
12560
12561	template<> inline const tflite::UnsortedSegmentMaxOptions Operator::builtin_options_as<tflite::UnsortedSegmentMaxOptions>() const* {
12562	return builtin_options_as_UnsortedSegmentMaxOptions();
12563	}
12564
12565	template<> inline const tflite::UnsortedSegmentMinOptions Operator::builtin_options_as<tflite::UnsortedSegmentMinOptions>() const* {
12566	return builtin_options_as_UnsortedSegmentMinOptions();
12567	}
12568
12569	template<> inline const tflite::UnsortedSegmentSumOptions Operator::builtin_options_as<tflite::UnsortedSegmentSumOptions>() const* {
12570	return builtin_options_as_UnsortedSegmentSumOptions();
12571	}
12572
12573	template<> inline const tflite::ATan2Options Operator::builtin_options_as<tflite::ATan2Options>() const* {
12574	return builtin_options_as_ATan2Options();
12575	}
12576
12577	template<> inline const tflite::SignOptions Operator::builtin_options_as<tflite::SignOptions>() const* {
12578	return builtin_options_as_SignOptions();
12579	}
12580
12581	struct OperatorBuilder {
12582	typedef Operator Table;
12583	flatbuffers::FlatBufferBuilder &fbb_;
12584	flatbuffers::uoffset_t start_;
12585	void add_opcode_index(uint32_t opcode_index) {
12586	fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, `0`);
12587	}
12588	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
12589	fbb_.AddOffset(Operator::VT_INPUTS, inputs);
12590	}
12591	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
12592	fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
12593	}
12594	void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {
12595	fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), `0`);
12596	}
12597	void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
12598	fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
12599	}
12600	void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
12601	fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
12602	}
12603	void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format) {
12604	fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), `0`);
12605	}
12606	void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
12607	fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
12608	}
12609	void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
12610	fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
12611	}
12612	explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
12613	: fbb_(_fbb) {
12614	start_ = fbb_.StartTable();
12615	}
12616	flatbuffers::Offset<Operator> Finish() {
12617	const auto end = fbb_.EndTable(start_);
12618	auto o = flatbuffers::Offset<Operator>(end);
12619	return o;
12620	}
12621	};
12622
12623	inline flatbuffers::Offset<Operator> CreateOperator(
12624	flatbuffers::FlatBufferBuilder &_fbb,
12625	uint32_t opcode_index = `0`,
12626	flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = `0`,
12627	flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = `0`,
12628	tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
12629	flatbuffers::Offset<void> builtin_options = `0`,
12630	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = `0`,
12631	tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
12632	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = `0`,
12633	flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = `0`) {
12634	OperatorBuilder builder_(_fbb);
12635	builder_.add_intermediates(intermediates);
12636	builder_.add_mutating_variable_inputs(mutating_variable_inputs);
12637	builder_.add_custom_options(custom_options);
12638	builder_.add_builtin_options(builtin_options);
12639	builder_.add_outputs(outputs);
12640	builder_.add_inputs(inputs);
12641	builder_.add_opcode_index(opcode_index);
12642	builder_.add_custom_options_format(custom_options_format);
12643	builder_.add_builtin_options_type(builtin_options_type);
12644	return builder_.Finish();
12645	}
12646
12647	inline flatbuffers::Offset<Operator> CreateOperatorDirect(
12648	flatbuffers::FlatBufferBuilder &_fbb,
12649	uint32_t opcode_index = `0`,
12650	const std::vector<int32_t> inputs = nullptr*,
12651	const std::vector<int32_t> outputs = nullptr*,
12652	tflite::BuiltinOptions builtin_options_type = tflite::BuiltinOptions_NONE,
12653	flatbuffers::Offset<void> builtin_options = `0`,
12654	const std::vector<uint8_t> custom_options = nullptr*,
12655	tflite::CustomOptionsFormat custom_options_format = tflite::CustomOptionsFormat_FLEXBUFFERS,
12656	const std::vector<uint8_t> mutating_variable_inputs = nullptr*,
12657	const std::vector<int32_t> intermediates = nullptr*) {
12658	auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : `0`;
12659	auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : `0`;
12660	auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : `0`;
12661	auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : `0`;
12662	auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : `0`;
12663	return tflite::CreateOperator(
12664	_fbb,
12665	opcode_index,
12666	inputs__,
12667	outputs__,
12668	builtin_options_type,
12669	builtin_options,
12670	custom_options__,
12671	custom_options_format,
12672	mutating_variable_inputs__,
12673	intermediates__);
12674	}
12675
12676	flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
12677
12678	struct SubGraphT : public flatbuffers::NativeTable {
12679	typedef SubGraph TableType;
12680	std::vector<std::unique_ptr<tflite::TensorT>> tensors{};
12681	std::vector<int32_t> inputs{};
12682	std::vector<int32_t> outputs{};
12683	std::vector<std::unique_ptr<tflite::OperatorT>> operators{};
12684	std::string name{};
12685	SubGraphT() = default;
12686	SubGraphT(const SubGraphT &o);
12687	SubGraphT(SubGraphT&&) FLATBUFFERS_NOEXCEPT = default;
12688	SubGraphT &operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT;
12689	};
12690
12691	struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12692	typedef SubGraphT NativeTableType;
12693	typedef SubGraphBuilder Builder;
12694	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12695	VT_TENSORS = `4`,
12696	VT_INPUTS = `6`,
12697	VT_OUTPUTS = `8`,
12698	VT_OPERATORS = `10`,
12699	VT_NAME = `12`
12700	};
12701	const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> tensors() const* {
12702	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
12703	}
12704	const flatbuffers::Vector<int32_t> inputs() const* {
12705	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
12706	}
12707	const flatbuffers::Vector<int32_t> outputs() const* {
12708	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
12709	}
12710	const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> operators() const* {
12711	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
12712	}
12713	const flatbuffers::String name() const* {
12714	return GetPointer<const flatbuffers::String *>(VT_NAME);
12715	}
12716	bool Verify(flatbuffers::Verifier &verifier) const {
12717	return VerifyTableStart(verifier) &&
12718	VerifyOffset(verifier, VT_TENSORS) &&
12719	verifier.VerifyVector(tensors()) &&
12720	verifier.VerifyVectorOfTables(tensors()) &&
12721	VerifyOffset(verifier, VT_INPUTS) &&
12722	verifier.VerifyVector(inputs()) &&
12723	VerifyOffset(verifier, VT_OUTPUTS) &&
12724	verifier.VerifyVector(outputs()) &&
12725	VerifyOffset(verifier, VT_OPERATORS) &&
12726	verifier.VerifyVector(operators()) &&
12727	verifier.VerifyVectorOfTables(operators()) &&
12728	VerifyOffset(verifier, VT_NAME) &&
12729	verifier.VerifyString(name()) &&
12730	verifier.EndTable();
12731	}
12732	SubGraphT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12733	void UnPackTo(SubGraphT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12734	static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
12735	};
12736
12737	struct SubGraphBuilder {
12738	typedef SubGraph Table;
12739	flatbuffers::FlatBufferBuilder &fbb_;
12740	flatbuffers::uoffset_t start_;
12741	void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors) {
12742	fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
12743	}
12744	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) {
12745	fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
12746	}
12747	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) {
12748	fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
12749	}
12750	void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators) {
12751	fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
12752	}
12753	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12754	fbb_.AddOffset(SubGraph::VT_NAME, name);
12755	}
12756	explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
12757	: fbb_(_fbb) {
12758	start_ = fbb_.StartTable();
12759	}
12760	flatbuffers::Offset<SubGraph> Finish() {
12761	const auto end = fbb_.EndTable(start_);
12762	auto o = flatbuffers::Offset<SubGraph>(end);
12763	return o;
12764	}
12765	};
12766
12767	inline flatbuffers::Offset<SubGraph> CreateSubGraph(
12768	flatbuffers::FlatBufferBuilder &_fbb,
12769	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors = `0`,
12770	flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = `0`,
12771	flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = `0`,
12772	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators = `0`,
12773	flatbuffers::Offset<flatbuffers::String> name = `0`) {
12774	SubGraphBuilder builder_(_fbb);
12775	builder_.add_name(name);
12776	builder_.add_operators(operators);
12777	builder_.add_outputs(outputs);
12778	builder_.add_inputs(inputs);
12779	builder_.add_tensors(tensors);
12780	return builder_.Finish();
12781	}
12782
12783	inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
12784	flatbuffers::FlatBufferBuilder &_fbb,
12785	const std::vector<flatbuffers::Offset<tflite::Tensor>> tensors = nullptr*,
12786	const std::vector<int32_t> inputs = nullptr*,
12787	const std::vector<int32_t> outputs = nullptr*,
12788	const std::vector<flatbuffers::Offset<tflite::Operator>> operators = nullptr*,
12789	const char name = nullptr*) {
12790	auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>>(*tensors) : `0`;
12791	auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : `0`;
12792	auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : `0`;
12793	auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>>(*operators) : `0`;
12794	auto name__ = name ? _fbb.CreateString(name) : `0`;
12795	return tflite::CreateSubGraph(
12796	_fbb,
12797	tensors__,
12798	inputs__,
12799	outputs__,
12800	operators__,
12801	name__);
12802	}
12803
12804	flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
12805
12806	struct BufferT : public flatbuffers::NativeTable {
12807	typedef Buffer TableType;
12808	std::vector<uint8_t> data{};
12809	};
12810
12811	struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12812	typedef BufferT NativeTableType;
12813	typedef BufferBuilder Builder;
12814	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12815	VT_DATA = `4`
12816	};
12817	const flatbuffers::Vector<uint8_t> data() const* {
12818	return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
12819	}
12820	bool Verify(flatbuffers::Verifier &verifier) const {
12821	return VerifyTableStart(verifier) &&
12822	VerifyOffset(verifier, VT_DATA) &&
12823	verifier.VerifyVector(data()) &&
12824	verifier.EndTable();
12825	}
12826	BufferT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12827	void UnPackTo(BufferT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12828	static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
12829	};
12830
12831	struct BufferBuilder {
12832	typedef Buffer Table;
12833	flatbuffers::FlatBufferBuilder &fbb_;
12834	flatbuffers::uoffset_t start_;
12835	void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
12836	fbb_.AddOffset(Buffer::VT_DATA, data);
12837	}
12838	explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
12839	: fbb_(_fbb) {
12840	start_ = fbb_.StartTable();
12841	}
12842	flatbuffers::Offset<Buffer> Finish() {
12843	const auto end = fbb_.EndTable(start_);
12844	auto o = flatbuffers::Offset<Buffer>(end);
12845	return o;
12846	}
12847	};
12848
12849	inline flatbuffers::Offset<Buffer> CreateBuffer(
12850	flatbuffers::FlatBufferBuilder &_fbb,
12851	flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = `0`) {
12852	BufferBuilder builder_(_fbb);
12853	builder_.add_data(data);
12854	return builder_.Finish();
12855	}
12856
12857	inline flatbuffers::Offset<Buffer> CreateBufferDirect(
12858	flatbuffers::FlatBufferBuilder &_fbb,
12859	const std::vector<uint8_t> data = nullptr*) {
12860	if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), `16`); }
12861	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : `0`;
12862	return tflite::CreateBuffer(
12863	_fbb,
12864	data__);
12865	}
12866
12867	flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
12868
12869	struct MetadataT : public flatbuffers::NativeTable {
12870	typedef Metadata TableType;
12871	std::string name{};
12872	uint32_t buffer = `0`;
12873	};
12874
12875	struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12876	typedef MetadataT NativeTableType;
12877	typedef MetadataBuilder Builder;
12878	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12879	VT_NAME = `4`,
12880	VT_BUFFER = `6`
12881	};
12882	const flatbuffers::String name() const* {
12883	return GetPointer<const flatbuffers::String *>(VT_NAME);
12884	}
12885	uint32_t buffer() const {
12886	return GetField<uint32_t>(VT_BUFFER, `0`);
12887	}
12888	bool Verify(flatbuffers::Verifier &verifier) const {
12889	return VerifyTableStart(verifier) &&
12890	VerifyOffset(verifier, VT_NAME) &&
12891	verifier.VerifyString(name()) &&
12892	VerifyField<uint32_t>(verifier, VT_BUFFER, `4`) &&
12893	verifier.EndTable();
12894	}
12895	MetadataT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12896	void UnPackTo(MetadataT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12897	static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
12898	};
12899
12900	struct MetadataBuilder {
12901	typedef Metadata Table;
12902	flatbuffers::FlatBufferBuilder &fbb_;
12903	flatbuffers::uoffset_t start_;
12904	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12905	fbb_.AddOffset(Metadata::VT_NAME, name);
12906	}
12907	void add_buffer(uint32_t buffer) {
12908	fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, `0`);
12909	}
12910	explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
12911	: fbb_(_fbb) {
12912	start_ = fbb_.StartTable();
12913	}
12914	flatbuffers::Offset<Metadata> Finish() {
12915	const auto end = fbb_.EndTable(start_);
12916	auto o = flatbuffers::Offset<Metadata>(end);
12917	return o;
12918	}
12919	};
12920
12921	inline flatbuffers::Offset<Metadata> CreateMetadata(
12922	flatbuffers::FlatBufferBuilder &_fbb,
12923	flatbuffers::Offset<flatbuffers::String> name = `0`,
12924	uint32_t buffer = `0`) {
12925	MetadataBuilder builder_(_fbb);
12926	builder_.add_buffer(buffer);
12927	builder_.add_name(name);
12928	return builder_.Finish();
12929	}
12930
12931	inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
12932	flatbuffers::FlatBufferBuilder &_fbb,
12933	const char name = nullptr*,
12934	uint32_t buffer = `0`) {
12935	auto name__ = name ? _fbb.CreateString(name) : `0`;
12936	return tflite::CreateMetadata(
12937	_fbb,
12938	name__,
12939	buffer);
12940	}
12941
12942	flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
12943
12944	struct TensorMapT : public flatbuffers::NativeTable {
12945	typedef TensorMap TableType;
12946	std::string name{};
12947	uint32_t tensor_index = `0`;
12948	};
12949
12950	struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12951	typedef TensorMapT NativeTableType;
12952	typedef TensorMapBuilder Builder;
12953	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12954	VT_NAME = `4`,
12955	VT_TENSOR_INDEX = `6`
12956	};
12957	const flatbuffers::String name() const* {
12958	return GetPointer<const flatbuffers::String *>(VT_NAME);
12959	}
12960	uint32_t tensor_index() const {
12961	return GetField<uint32_t>(VT_TENSOR_INDEX, `0`);
12962	}
12963	bool Verify(flatbuffers::Verifier &verifier) const {
12964	return VerifyTableStart(verifier) &&
12965	VerifyOffset(verifier, VT_NAME) &&
12966	verifier.VerifyString(name()) &&
12967	VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX, `4`) &&
12968	verifier.EndTable();
12969	}
12970	TensorMapT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12971	void UnPackTo(TensorMapT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
12972	static flatbuffers::Offset<TensorMap> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
12973	};
12974
12975	struct TensorMapBuilder {
12976	typedef TensorMap Table;
12977	flatbuffers::FlatBufferBuilder &fbb_;
12978	flatbuffers::uoffset_t start_;
12979	void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12980	fbb_.AddOffset(TensorMap::VT_NAME, name);
12981	}
12982	void add_tensor_index(uint32_t tensor_index) {
12983	fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, `0`);
12984	}
12985	explicit TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
12986	: fbb_(_fbb) {
12987	start_ = fbb_.StartTable();
12988	}
12989	flatbuffers::Offset<TensorMap> Finish() {
12990	const auto end = fbb_.EndTable(start_);
12991	auto o = flatbuffers::Offset<TensorMap>(end);
12992	return o;
12993	}
12994	};
12995
12996	inline flatbuffers::Offset<TensorMap> CreateTensorMap(
12997	flatbuffers::FlatBufferBuilder &_fbb,
12998	flatbuffers::Offset<flatbuffers::String> name = `0`,
12999	uint32_t tensor_index = `0`) {
13000	TensorMapBuilder builder_(_fbb);
13001	builder_.add_tensor_index(tensor_index);
13002	builder_.add_name(name);
13003	return builder_.Finish();
13004	}
13005
13006	inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
13007	flatbuffers::FlatBufferBuilder &_fbb,
13008	const char name = nullptr*,
13009	uint32_t tensor_index = `0`) {
13010	auto name__ = name ? _fbb.CreateString(name) : `0`;
13011	return tflite::CreateTensorMap(
13012	_fbb,
13013	name__,
13014	tensor_index);
13015	}
13016
13017	flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
13018
13019	struct SignatureDefT : public flatbuffers::NativeTable {
13020	typedef SignatureDef TableType;
13021	std::vector<std::unique_ptr<tflite::TensorMapT>> inputs{};
13022	std::vector<std::unique_ptr<tflite::TensorMapT>> outputs{};
13023	std::string signature_key{};
13024	uint32_t subgraph_index = `0`;
13025	SignatureDefT() = default;
13026	SignatureDefT(const SignatureDefT &o);
13027	SignatureDefT(SignatureDefT&&) FLATBUFFERS_NOEXCEPT = default;
13028	SignatureDefT &operator=(SignatureDefT o) FLATBUFFERS_NOEXCEPT;
13029	};
13030
13031	struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
13032	typedef SignatureDefT NativeTableType;
13033	typedef SignatureDefBuilder Builder;
13034	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
13035	VT_INPUTS = `4`,
13036	VT_OUTPUTS = `6`,
13037	VT_SIGNATURE_KEY = `8`,
13038	VT_SUBGRAPH_INDEX = `12`
13039	};
13040	const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> inputs() const* {
13041	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
13042	}
13043	const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> outputs() const* {
13044	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
13045	}
13046	const flatbuffers::String signature_key() const* {
13047	return GetPointer<const flatbuffers::String *>(VT_SIGNATURE_KEY);
13048	}
13049	uint32_t subgraph_index() const {
13050	return GetField<uint32_t>(VT_SUBGRAPH_INDEX, `0`);
13051	}
13052	bool Verify(flatbuffers::Verifier &verifier) const {
13053	return VerifyTableStart(verifier) &&
13054	VerifyOffset(verifier, VT_INPUTS) &&
13055	verifier.VerifyVector(inputs()) &&
13056	verifier.VerifyVectorOfTables(inputs()) &&
13057	VerifyOffset(verifier, VT_OUTPUTS) &&
13058	verifier.VerifyVector(outputs()) &&
13059	verifier.VerifyVectorOfTables(outputs()) &&
13060	VerifyOffset(verifier, VT_SIGNATURE_KEY) &&
13061	verifier.VerifyString(signature_key()) &&
13062	VerifyField<uint32_t>(verifier, VT_SUBGRAPH_INDEX, `4`) &&
13063	verifier.EndTable();
13064	}
13065	SignatureDefT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
13066	void UnPackTo(SignatureDefT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
13067	static flatbuffers::Offset<SignatureDef> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
13068	};
13069
13070	struct SignatureDefBuilder {
13071	typedef SignatureDef Table;
13072	flatbuffers::FlatBufferBuilder &fbb_;
13073	flatbuffers::uoffset_t start_;
13074	void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs) {
13075	fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
13076	}
13077	void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs) {
13078	fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
13079	}
13080	void add_signature_key(flatbuffers::Offset<flatbuffers::String> signature_key) {
13081	fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key);
13082	}
13083	void add_subgraph_index(uint32_t subgraph_index) {
13084	fbb_.AddElement<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, `0`);
13085	}
13086	explicit SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
13087	: fbb_(_fbb) {
13088	start_ = fbb_.StartTable();
13089	}
13090	flatbuffers::Offset<SignatureDef> Finish() {
13091	const auto end = fbb_.EndTable(start_);
13092	auto o = flatbuffers::Offset<SignatureDef>(end);
13093	return o;
13094	}
13095	};
13096
13097	inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
13098	flatbuffers::FlatBufferBuilder &_fbb,
13099	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs = `0`,
13100	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs = `0`,
13101	flatbuffers::Offset<flatbuffers::String> signature_key = `0`,
13102	uint32_t subgraph_index = `0`) {
13103	SignatureDefBuilder builder_(_fbb);
13104	builder_.add_subgraph_index(subgraph_index);
13105	builder_.add_signature_key(signature_key);
13106	builder_.add_outputs(outputs);
13107	builder_.add_inputs(inputs);
13108	return builder_.Finish();
13109	}
13110
13111	inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
13112	flatbuffers::FlatBufferBuilder &_fbb,
13113	const std::vector<flatbuffers::Offset<tflite::TensorMap>> inputs = nullptr*,
13114	const std::vector<flatbuffers::Offset<tflite::TensorMap>> outputs = nullptr*,
13115	const char signature_key = nullptr*,
13116	uint32_t subgraph_index = `0`) {
13117	auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*inputs) : `0`;
13118	auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*outputs) : `0`;
13119	auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : `0`;
13120	return tflite::CreateSignatureDef(
13121	_fbb,
13122	inputs__,
13123	outputs__,
13124	signature_key__,
13125	subgraph_index);
13126	}
13127
13128	flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
13129
13130	struct ModelT : public flatbuffers::NativeTable {
13131	typedef Model TableType;
13132	uint32_t version = `0`;
13133	std::vector<std::unique_ptr<tflite::OperatorCodeT>> operator_codes{};
13134	std::vector<std::unique_ptr<tflite::SubGraphT>> subgraphs{};
13135	std::string description{};
13136	std::vector<std::unique_ptr<tflite::BufferT>> buffers{};
13137	std::vector<int32_t> metadata_buffer{};
13138	std::vector<std::unique_ptr<tflite::MetadataT>> metadata{};
13139	std::vector<std::unique_ptr<tflite::SignatureDefT>> signature_defs{};
13140	ModelT() = default;
13141	ModelT(const ModelT &o);
13142	ModelT(ModelT&&) FLATBUFFERS_NOEXCEPT = default;
13143	ModelT &operator=(ModelT o) FLATBUFFERS_NOEXCEPT;
13144	};
13145
13146	struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
13147	typedef ModelT NativeTableType;
13148	typedef ModelBuilder Builder;
13149	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
13150	VT_VERSION = `4`,
13151	VT_OPERATOR_CODES = `6`,
13152	VT_SUBGRAPHS = `8`,
13153	VT_DESCRIPTION = `10`,
13154	VT_BUFFERS = `12`,
13155	VT_METADATA_BUFFER = `14`,
13156	VT_METADATA = `16`,
13157	VT_SIGNATURE_DEFS = `18`
13158	};
13159	uint32_t version() const {
13160	return GetField<uint32_t>(VT_VERSION, `0`);
13161	}
13162	const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> operator_codes() const* {
13163	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
13164	}
13165	const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> subgraphs() const* {
13166	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
13167	}
13168	const flatbuffers::String description() const* {
13169	return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
13170	}
13171	const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> buffers() const* {
13172	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
13173	}
13174	const flatbuffers::Vector<int32_t> metadata_buffer() const* {
13175	return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
13176	}
13177	const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> metadata() const* {
13178	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
13179	}
13180	const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> signature_defs() const* {
13181	return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
13182	}
13183	bool Verify(flatbuffers::Verifier &verifier) const {
13184	return VerifyTableStart(verifier) &&
13185	VerifyField<uint32_t>(verifier, VT_VERSION, `4`) &&
13186	VerifyOffset(verifier, VT_OPERATOR_CODES) &&
13187	verifier.VerifyVector(operator_codes()) &&
13188	verifier.VerifyVectorOfTables(operator_codes()) &&
13189	VerifyOffset(verifier, VT_SUBGRAPHS) &&
13190	verifier.VerifyVector(subgraphs()) &&
13191	verifier.VerifyVectorOfTables(subgraphs()) &&
13192	VerifyOffset(verifier, VT_DESCRIPTION) &&
13193	verifier.VerifyString(description()) &&
13194	VerifyOffset(verifier, VT_BUFFERS) &&
13195	verifier.VerifyVector(buffers()) &&
13196	verifier.VerifyVectorOfTables(buffers()) &&
13197	VerifyOffset(verifier, VT_METADATA_BUFFER) &&
13198	verifier.VerifyVector(metadata_buffer()) &&
13199	VerifyOffset(verifier, VT_METADATA) &&
13200	verifier.VerifyVector(metadata()) &&
13201	verifier.VerifyVectorOfTables(metadata()) &&
13202	VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
13203	verifier.VerifyVector(signature_defs()) &&
13204	verifier.VerifyVectorOfTables(signature_defs()) &&
13205	verifier.EndTable();
13206	}
13207	ModelT UnPack(const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
13208	void UnPackTo(ModelT _o, const* flatbuffers::resolver_function_t _resolver = nullptr) const*;
13209	static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t _rehasher = nullptr*);
13210	};
13211
13212	struct ModelBuilder {
13213	typedef Model Table;
13214	flatbuffers::FlatBufferBuilder &fbb_;
13215	flatbuffers::uoffset_t start_;
13216	void add_version(uint32_t version) {
13217	fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, `0`);
13218	}
13219	void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
13220	fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
13221	}
13222	void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
13223	fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
13224	}
13225	void add_description(flatbuffers::Offset<flatbuffers::String> description) {
13226	fbb_.AddOffset(Model::VT_DESCRIPTION, description);
13227	}
13228	void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers) {
13229	fbb_.AddOffset(Model::VT_BUFFERS, buffers);
13230	}
13231	void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
13232	fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
13233	}
13234	void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata) {
13235	fbb_.AddOffset(Model::VT_METADATA, metadata);
13236	}
13237	void add_signature_defs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
13238	fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
13239	}
13240	explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
13241	: fbb_(_fbb) {
13242	start_ = fbb_.StartTable();
13243	}
13244	flatbuffers::Offset<Model> Finish() {
13245	const auto end = fbb_.EndTable(start_);
13246	auto o = flatbuffers::Offset<Model>(end);
13247	return o;
13248	}
13249	};
13250
13251	inline flatbuffers::Offset<Model> CreateModel(
13252	flatbuffers::FlatBufferBuilder &_fbb,
13253	uint32_t version = `0`,
13254	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = `0`,
13255	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs = `0`,
13256	flatbuffers::Offset<flatbuffers::String> description = `0`,
13257	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers = `0`,
13258	flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = `0`,
13259	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata = `0`,
13260	flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = `0`) {
13261	ModelBuilder builder_(_fbb);
13262	builder_.add_signature_defs(signature_defs);
13263	builder_.add_metadata(metadata);
13264	builder_.add_metadata_buffer(metadata_buffer);
13265	builder_.add_buffers(buffers);
13266	builder_.add_description(description);
13267	builder_.add_subgraphs(subgraphs);
13268	builder_.add_operator_codes(operator_codes);
13269	builder_.add_version(version);
13270	return builder_.Finish();
13271	}
13272
13273	inline flatbuffers::Offset<Model> CreateModelDirect(
13274	flatbuffers::FlatBufferBuilder &_fbb,
13275	uint32_t version = `0`,
13276	const std::vector<flatbuffers::Offset<tflite::OperatorCode>> operator_codes = nullptr*,
13277	const std::vector<flatbuffers::Offset<tflite::SubGraph>> subgraphs = nullptr*,
13278	const char description = nullptr*,
13279	const std::vector<flatbuffers::Offset<tflite::Buffer>> buffers = nullptr*,
13280	const std::vector<int32_t> metadata_buffer = nullptr*,
13281	const std::vector<flatbuffers::Offset<tflite::Metadata>> metadata = nullptr*,
13282	const std::vector<flatbuffers::Offset<tflite::SignatureDef>> signature_defs = nullptr*) {
13283	auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : `0`;
13284	auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : `0`;
13285	auto description__ = description ? _fbb.CreateString(description) : `0`;
13286	auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>>(*buffers) : `0`;
13287	auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : `0`;
13288	auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>>(*metadata) : `0`;
13289	auto signature_defs__ = signature_defs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : `0`;
13290	return tflite::CreateModel(
13291	_fbb,
13292	version,
13293	operator_codes__,
13294	subgraphs__,
13295	description__,
13296	buffers__,
13297	metadata_buffer__,
13298	metadata__,
13299	signature_defs__);
13300	}
13301
13302	flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT _o, const* flatbuffers::rehasher_function_t _rehasher = nullptr*);
13303
13304	inline CustomQuantizationT CustomQuantization::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13305	auto _o = std::unique_ptr<CustomQuantizationT>(new CustomQuantizationT ());
13306	UnPackTo(_o.get(), _resolver);
13307	return _o.release();
13308	}
13309
13310	inline void CustomQuantization::UnPackTo(CustomQuantizationT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13311	(void)_o;
13312	(void)_resolver;
13313	{ auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom.begin()); } }
13314	}
13315
13316	inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13317	return CreateCustomQuantization(_fbb, _o, _rehasher);
13318	}
13319
13320	inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13321	(void)_rehasher;
13322	(void)_o;
13323	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CustomQuantizationT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13324	_fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), `16`);
13325	auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : `0`;
13326	return tflite::CreateCustomQuantization(
13327	_fbb,
13328	_custom);
13329	}
13330
13331	inline QuantizationParametersT QuantizationParameters::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13332	auto _o = std::unique_ptr<QuantizationParametersT>(new QuantizationParametersT ());
13333	UnPackTo(_o.get(), _resolver);
13334	return _o.release();
13335	}
13336
13337	inline void QuantizationParameters::UnPackTo(QuantizationParametersT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13338	(void)_o;
13339	(void)_resolver;
13340	{ auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->min [_i] = _e->Get(_i); } } }
13341	{ auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->max [_i] = _e->Get(_i); } } }
13342	{ auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->scale [_i] = _e->Get(_i); } } }
13343	{ auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->zero_point [_i] = _e->Get(_i); } } }
13344	{ auto _e = details_type(); _o->details.type = _e; }
13345	{ auto _e = details(); if (_e) _o->details.value = tflite::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); }
13346	{ auto _e = quantized_dimension(); _o->quantized_dimension = _e; }
13347	}
13348
13349	inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13350	return CreateQuantizationParameters(_fbb, _o, _rehasher);
13351	}
13352
13353	inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13354	(void)_rehasher;
13355	(void)_o;
13356	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* QuantizationParametersT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13357	auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : `0`;
13358	auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : `0`;
13359	auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : `0`;
13360	auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : `0`;
13361	auto _details_type = _o->details.type;
13362	auto _details = _o->details.Pack(_fbb);
13363	auto _quantized_dimension = _o->quantized_dimension;
13364	return tflite::CreateQuantizationParameters(
13365	_fbb,
13366	_min,
13367	_max,
13368	_scale,
13369	_zero_point,
13370	_details_type,
13371	_details,
13372	_quantized_dimension);
13373	}
13374
13375	inline Int32VectorT Int32Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13376	auto _o = std::unique_ptr<Int32VectorT>(new Int32VectorT ());
13377	UnPackTo(_o.get(), _resolver);
13378	return _o.release();
13379	}
13380
13381	inline void Int32Vector::UnPackTo(Int32VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13382	(void)_o;
13383	(void)_resolver;
13384	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->values [_i] = _e->Get(_i); } } }
13385	}
13386
13387	inline flatbuffers::Offset<Int32Vector> Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13388	return CreateInt32Vector(_fbb, _o, _rehasher);
13389	}
13390
13391	inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13392	(void)_rehasher;
13393	(void)_o;
13394	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Int32VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13395	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
13396	return tflite::CreateInt32Vector(
13397	_fbb,
13398	_values);
13399	}
13400
13401	inline Uint16VectorT Uint16Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13402	auto _o = std::unique_ptr<Uint16VectorT>(new Uint16VectorT ());
13403	UnPackTo(_o.get(), _resolver);
13404	return _o.release();
13405	}
13406
13407	inline void Uint16Vector::UnPackTo(Uint16VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13408	(void)_o;
13409	(void)_resolver;
13410	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->values [_i] = _e->Get(_i); } } }
13411	}
13412
13413	inline flatbuffers::Offset<Uint16Vector> Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13414	return CreateUint16Vector(_fbb, _o, _rehasher);
13415	}
13416
13417	inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13418	(void)_rehasher;
13419	(void)_o;
13420	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Uint16VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13421	_fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), `4`);
13422	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
13423	return tflite::CreateUint16Vector(
13424	_fbb,
13425	_values);
13426	}
13427
13428	inline Uint8VectorT Uint8Vector::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13429	auto _o = std::unique_ptr<Uint8VectorT>(new Uint8VectorT ());
13430	UnPackTo(_o.get(), _resolver);
13431	return _o.release();
13432	}
13433
13434	inline void Uint8Vector::UnPackTo(Uint8VectorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13435	(void)_o;
13436	(void)_resolver;
13437	{ auto _e = values(); if (_e) { _o->values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->values.begin()); } }
13438	}
13439
13440	inline flatbuffers::Offset<Uint8Vector> Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13441	return CreateUint8Vector(_fbb, _o, _rehasher);
13442	}
13443
13444	inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13445	(void)_rehasher;
13446	(void)_o;
13447	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Uint8VectorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13448	_fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), `4`);
13449	auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : `0`;
13450	return tflite::CreateUint8Vector(
13451	_fbb,
13452	_values);
13453	}
13454
13455	inline DimensionMetadataT DimensionMetadata::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13456	auto _o = std::unique_ptr<DimensionMetadataT>(new DimensionMetadataT ());
13457	UnPackTo(_o.get(), _resolver);
13458	return _o.release();
13459	}
13460
13461	inline void DimensionMetadata::UnPackTo(DimensionMetadataT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13462	(void)_o;
13463	(void)_resolver;
13464	{ auto _e = format(); _o->format = _e; }
13465	{ auto _e = dense_size(); _o->dense_size = _e; }
13466	{ auto _e = array_segments_type(); _o->array_segments.type = _e; }
13467	{ auto _e = array_segments(); if (_e) _o->array_segments.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_segments_type(), _resolver); }
13468	{ auto _e = array_indices_type(); _o->array_indices.type = _e; }
13469	{ auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); }
13470	}
13471
13472	inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13473	return CreateDimensionMetadata(_fbb, _o, _rehasher);
13474	}
13475
13476	inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13477	(void)_rehasher;
13478	(void)_o;
13479	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DimensionMetadataT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13480	auto _format = _o->format;
13481	auto _dense_size = _o->dense_size;
13482	auto _array_segments_type = _o->array_segments.type;
13483	auto _array_segments = _o->array_segments.Pack(_fbb);
13484	auto _array_indices_type = _o->array_indices.type;
13485	auto _array_indices = _o->array_indices.Pack(_fbb);
13486	return tflite::CreateDimensionMetadata(
13487	_fbb,
13488	_format,
13489	_dense_size,
13490	_array_segments_type,
13491	_array_segments,
13492	_array_indices_type,
13493	_array_indices);
13494	}
13495
13496	inline SparsityParametersT::SparsityParametersT(const SparsityParametersT &o)
13497	: traversal_order (o.traversal_order),
13498	block_map (o.block_map) {
13499	dim_metadata.reserve(o.dim_metadata.size());
13500	for (const auto &v : o.dim_metadata) { dim_metadata.emplace_back((v) ? new tflite::DimensionMetadataT (v) : nullptr*); }
13501	}
13502
13503	inline SparsityParametersT &SparsityParametersT::operator=(SparsityParametersT o) FLATBUFFERS_NOEXCEPT {
13504	std::swap(traversal_order, o.traversal_order);
13505	std::swap(block_map, o.block_map);
13506	std::swap(dim_metadata, o.dim_metadata);
13507	return *this;
13508	}
13509
13510	inline SparsityParametersT SparsityParameters::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13511	auto _o = std::unique_ptr<SparsityParametersT>(new SparsityParametersT ());
13512	UnPackTo(_o.get(), _resolver);
13513	return _o.release();
13514	}
13515
13516	inline void SparsityParameters::UnPackTo(SparsityParametersT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13517	(void)_o;
13518	(void)_resolver;
13519	{ auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->traversal_order [_i] = _e->Get(_i); } } }
13520	{ auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->block_map [_i] = _e->Get(_i); } } }
13521	{ auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->dim_metadata [_i]) { _e->Get(_i)->UnPackTo(_o->dim_metadata [_i].get(), _resolver); } else { _o->dim_metadata [_i] = std::unique_ptr<tflite::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
13522	}
13523
13524	inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13525	return CreateSparsityParameters(_fbb, _o, _rehasher);
13526	}
13527
13528	inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13529	(void)_rehasher;
13530	(void)_o;
13531	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SparsityParametersT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13532	auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : `0`;
13533	auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : `0`;
13534	auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>> (_o->dim_metadata.size(), [](size_t i, _VectorArgs __va) { return* CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata [i].get(), __va->__rehasher); }, &_va ) : `0`;
13535	return tflite::CreateSparsityParameters(
13536	_fbb,
13537	_traversal_order,
13538	_block_map,
13539	_dim_metadata);
13540	}
13541
13542	inline VariantSubTypeT VariantSubType::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13543	auto _o = std::unique_ptr<VariantSubTypeT>(new VariantSubTypeT ());
13544	UnPackTo(_o.get(), _resolver);
13545	return _o.release();
13546	}
13547
13548	inline void VariantSubType::UnPackTo(VariantSubTypeT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13549	(void)_o;
13550	(void)_resolver;
13551	{ auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->shape [_i] = _e->Get(_i); } } }
13552	{ auto _e = type(); _o->type = _e; }
13553	{ auto _e = has_rank(); _o->has_rank = _e; }
13554	}
13555
13556	inline flatbuffers::Offset<VariantSubType> VariantSubType::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13557	return CreateVariantSubType(_fbb, _o, _rehasher);
13558	}
13559
13560	inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13561	(void)_rehasher;
13562	(void)_o;
13563	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* VariantSubTypeT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13564	auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : `0`;
13565	auto _type = _o->type;
13566	auto _has_rank = _o->has_rank;
13567	return tflite::CreateVariantSubType(
13568	_fbb,
13569	_shape,
13570	_type,
13571	_has_rank);
13572	}
13573
13574	inline TensorT::TensorT(const TensorT &o)
13575	: shape (o.shape),
13576	type(o.type),
13577	buffer(o.buffer),
13578	name (o.name),
13579	quantization ((o.quantization) ? new tflite::QuantizationParametersT (o.quantization) : nullptr*),
13580	is_variable(o.is_variable),
13581	sparsity ((o.sparsity) ? new tflite::SparsityParametersT (o.sparsity) : nullptr*),
13582	shape_signature (o.shape_signature),
13583	has_rank(o.has_rank) {
13584	variant_tensors.reserve(o.variant_tensors.size());
13585	for (const auto &v : o.variant_tensors) { variant_tensors.emplace_back((v) ? new tflite::VariantSubTypeT (v) : nullptr*); }
13586	}
13587
13588	inline TensorT &TensorT::operator=(TensorT o) FLATBUFFERS_NOEXCEPT {
13589	std::swap(shape, o.shape);
13590	std::swap(type, o.type);
13591	std::swap(buffer, o.buffer);
13592	std::swap(name, o.name);
13593	std::swap(quantization, o.quantization);
13594	std::swap(is_variable, o.is_variable);
13595	std::swap(sparsity, o.sparsity);
13596	std::swap(shape_signature, o.shape_signature);
13597	std::swap(has_rank, o.has_rank);
13598	std::swap(variant_tensors, o.variant_tensors);
13599	return *this;
13600	}
13601
13602	inline TensorT Tensor::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13603	auto _o = std::unique_ptr<TensorT>(new TensorT ());
13604	UnPackTo(_o.get(), _resolver);
13605	return _o.release();
13606	}
13607
13608	inline void Tensor::UnPackTo(TensorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13609	(void)_o;
13610	(void)_resolver;
13611	{ auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->shape [_i] = _e->Get(_i); } } }
13612	{ auto _e = type(); _o->type = _e; }
13613	{ auto _e = buffer(); _o->buffer = _e; }
13614	{ auto _e = name(); if (_e) _o->name = _e->str(); }
13615	{ auto _e = quantization(); if (_e) { if(_o->quantization) { _e->UnPackTo(_o->quantization.get(), _resolver); } else { _o->quantization = std::unique_ptr<tflite::QuantizationParametersT>(_e->UnPack(_resolver)); } } }
13616	{ auto _e = is_variable(); _o->is_variable = _e; }
13617	{ auto _e = sparsity(); if (_e) { if(_o->sparsity) { _e->UnPackTo(_o->sparsity.get(), _resolver); } else { _o->sparsity = std::unique_ptr<tflite::SparsityParametersT>(_e->UnPack(_resolver)); } } }
13618	{ auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->shape_signature [_i] = _e->Get(_i); } } }
13619	{ auto _e = has_rank(); _o->has_rank = _e; }
13620	{ auto _e = variant_tensors(); if (_e) { _o->variant_tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->variant_tensors [_i]) { _e->Get(_i)->UnPackTo(_o->variant_tensors [_i].get(), _resolver); } else { _o->variant_tensors [_i] = std::unique_ptr<tflite::VariantSubTypeT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
13621	}
13622
13623	inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13624	return CreateTensor(_fbb, _o, _rehasher);
13625	}
13626
13627	inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13628	(void)_rehasher;
13629	(void)_o;
13630	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TensorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13631	auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : `0`;
13632	auto _type = _o->type;
13633	auto _buffer = _o->buffer;
13634	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
13635	auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : `0`;
13636	auto _is_variable = _o->is_variable;
13637	auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : `0`;
13638	auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : `0`;
13639	auto _has_rank = _o->has_rank;
13640	auto _variant_tensors = _o->variant_tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::VariantSubType>> (_o->variant_tensors.size(), [](size_t i, _VectorArgs __va) { return* CreateVariantSubType(*__va->__fbb, __va->__o->variant_tensors [i].get(), __va->__rehasher); }, &_va ) : `0`;
13641	return tflite::CreateTensor(
13642	_fbb,
13643	_shape,
13644	_type,
13645	_buffer,
13646	_name,
13647	_quantization,
13648	_is_variable,
13649	_sparsity,
13650	_shape_signature,
13651	_has_rank,
13652	_variant_tensors);
13653	}
13654
13655	inline Conv2DOptionsT Conv2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13656	auto _o = std::unique_ptr<Conv2DOptionsT>(new Conv2DOptionsT ());
13657	UnPackTo(_o.get(), _resolver);
13658	return _o.release();
13659	}
13660
13661	inline void Conv2DOptions::UnPackTo(Conv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13662	(void)_o;
13663	(void)_resolver;
13664	{ auto _e = padding(); _o->padding = _e; }
13665	{ auto _e = stride_w(); _o->stride_w = _e; }
13666	{ auto _e = stride_h(); _o->stride_h = _e; }
13667	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13668	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13669	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13670	}
13671
13672	inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13673	return CreateConv2DOptions(_fbb, _o, _rehasher);
13674	}
13675
13676	inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13677	(void)_rehasher;
13678	(void)_o;
13679	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13680	auto _padding = _o->padding;
13681	auto _stride_w = _o->stride_w;
13682	auto _stride_h = _o->stride_h;
13683	auto _fused_activation_function = _o->fused_activation_function;
13684	auto _dilation_w_factor = _o->dilation_w_factor;
13685	auto _dilation_h_factor = _o->dilation_h_factor;
13686	return tflite::CreateConv2DOptions(
13687	_fbb,
13688	_padding,
13689	_stride_w,
13690	_stride_h,
13691	_fused_activation_function,
13692	_dilation_w_factor,
13693	_dilation_h_factor);
13694	}
13695
13696	inline Conv3DOptionsT Conv3DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13697	auto _o = std::unique_ptr<Conv3DOptionsT>(new Conv3DOptionsT ());
13698	UnPackTo(_o.get(), _resolver);
13699	return _o.release();
13700	}
13701
13702	inline void Conv3DOptions::UnPackTo(Conv3DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13703	(void)_o;
13704	(void)_resolver;
13705	{ auto _e = padding(); _o->padding = _e; }
13706	{ auto _e = stride_d(); _o->stride_d = _e; }
13707	{ auto _e = stride_w(); _o->stride_w = _e; }
13708	{ auto _e = stride_h(); _o->stride_h = _e; }
13709	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13710	{ auto _e = dilation_d_factor(); _o->dilation_d_factor = _e; }
13711	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13712	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13713	}
13714
13715	inline flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13716	return CreateConv3DOptions(_fbb, _o, _rehasher);
13717	}
13718
13719	inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13720	(void)_rehasher;
13721	(void)_o;
13722	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Conv3DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13723	auto _padding = _o->padding;
13724	auto _stride_d = _o->stride_d;
13725	auto _stride_w = _o->stride_w;
13726	auto _stride_h = _o->stride_h;
13727	auto _fused_activation_function = _o->fused_activation_function;
13728	auto _dilation_d_factor = _o->dilation_d_factor;
13729	auto _dilation_w_factor = _o->dilation_w_factor;
13730	auto _dilation_h_factor = _o->dilation_h_factor;
13731	return tflite::CreateConv3DOptions(
13732	_fbb,
13733	_padding,
13734	_stride_d,
13735	_stride_w,
13736	_stride_h,
13737	_fused_activation_function,
13738	_dilation_d_factor,
13739	_dilation_w_factor,
13740	_dilation_h_factor);
13741	}
13742
13743	inline Pool2DOptionsT Pool2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13744	auto _o = std::unique_ptr<Pool2DOptionsT>(new Pool2DOptionsT ());
13745	UnPackTo(_o.get(), _resolver);
13746	return _o.release();
13747	}
13748
13749	inline void Pool2DOptions::UnPackTo(Pool2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13750	(void)_o;
13751	(void)_resolver;
13752	{ auto _e = padding(); _o->padding = _e; }
13753	{ auto _e = stride_w(); _o->stride_w = _e; }
13754	{ auto _e = stride_h(); _o->stride_h = _e; }
13755	{ auto _e = filter_width(); _o->filter_width = _e; }
13756	{ auto _e = filter_height(); _o->filter_height = _e; }
13757	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13758	}
13759
13760	inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13761	return CreatePool2DOptions(_fbb, _o, _rehasher);
13762	}
13763
13764	inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13765	(void)_rehasher;
13766	(void)_o;
13767	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13768	auto _padding = _o->padding;
13769	auto _stride_w = _o->stride_w;
13770	auto _stride_h = _o->stride_h;
13771	auto _filter_width = _o->filter_width;
13772	auto _filter_height = _o->filter_height;
13773	auto _fused_activation_function = _o->fused_activation_function;
13774	return tflite::CreatePool2DOptions(
13775	_fbb,
13776	_padding,
13777	_stride_w,
13778	_stride_h,
13779	_filter_width,
13780	_filter_height,
13781	_fused_activation_function);
13782	}
13783
13784	inline DepthwiseConv2DOptionsT DepthwiseConv2DOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13785	auto _o = std::unique_ptr<DepthwiseConv2DOptionsT>(new DepthwiseConv2DOptionsT ());
13786	UnPackTo(_o.get(), _resolver);
13787	return _o.release();
13788	}
13789
13790	inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13791	(void)_o;
13792	(void)_resolver;
13793	{ auto _e = padding(); _o->padding = _e; }
13794	{ auto _e = stride_w(); _o->stride_w = _e; }
13795	{ auto _e = stride_h(); _o->stride_h = _e; }
13796	{ auto _e = depth_multiplier(); _o->depth_multiplier = _e; }
13797	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13798	{ auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13799	{ auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13800	}
13801
13802	inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13803	return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
13804	}
13805
13806	inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13807	(void)_rehasher;
13808	(void)_o;
13809	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13810	auto _padding = _o->padding;
13811	auto _stride_w = _o->stride_w;
13812	auto _stride_h = _o->stride_h;
13813	auto _depth_multiplier = _o->depth_multiplier;
13814	auto _fused_activation_function = _o->fused_activation_function;
13815	auto _dilation_w_factor = _o->dilation_w_factor;
13816	auto _dilation_h_factor = _o->dilation_h_factor;
13817	return tflite::CreateDepthwiseConv2DOptions(
13818	_fbb,
13819	_padding,
13820	_stride_w,
13821	_stride_h,
13822	_depth_multiplier,
13823	_fused_activation_function,
13824	_dilation_w_factor,
13825	_dilation_h_factor);
13826	}
13827
13828	inline ConcatEmbeddingsOptionsT ConcatEmbeddingsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13829	auto _o = std::unique_ptr<ConcatEmbeddingsOptionsT>(new ConcatEmbeddingsOptionsT ());
13830	UnPackTo(_o.get(), _resolver);
13831	return _o.release();
13832	}
13833
13834	inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13835	(void)_o;
13836	(void)_resolver;
13837	{ auto _e = num_channels(); _o->num_channels = _e; }
13838	{ auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->num_columns_per_channel [_i] = _e->Get(_i); } } }
13839	{ auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->embedding_dim_per_channel [_i] = _e->Get(_i); } } }
13840	}
13841
13842	inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13843	return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
13844	}
13845
13846	inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13847	(void)_rehasher;
13848	(void)_o;
13849	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13850	auto _num_channels = _o->num_channels;
13851	auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : `0`;
13852	auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : `0`;
13853	return tflite::CreateConcatEmbeddingsOptions(
13854	_fbb,
13855	_num_channels,
13856	_num_columns_per_channel,
13857	_embedding_dim_per_channel);
13858	}
13859
13860	inline LSHProjectionOptionsT LSHProjectionOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13861	auto _o = std::unique_ptr<LSHProjectionOptionsT>(new LSHProjectionOptionsT ());
13862	UnPackTo(_o.get(), _resolver);
13863	return _o.release();
13864	}
13865
13866	inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13867	(void)_o;
13868	(void)_resolver;
13869	{ auto _e = type(); _o->type = _e; }
13870	}
13871
13872	inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13873	return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
13874	}
13875
13876	inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13877	(void)_rehasher;
13878	(void)_o;
13879	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13880	auto _type = _o->type;
13881	return tflite::CreateLSHProjectionOptions(
13882	_fbb,
13883	_type);
13884	}
13885
13886	inline SVDFOptionsT SVDFOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13887	auto _o = std::unique_ptr<SVDFOptionsT>(new SVDFOptionsT ());
13888	UnPackTo(_o.get(), _resolver);
13889	return _o.release();
13890	}
13891
13892	inline void SVDFOptions::UnPackTo(SVDFOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13893	(void)_o;
13894	(void)_resolver;
13895	{ auto _e = rank(); _o->rank = _e; }
13896	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13897	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13898	}
13899
13900	inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13901	return CreateSVDFOptions(_fbb, _o, _rehasher);
13902	}
13903
13904	inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13905	(void)_rehasher;
13906	(void)_o;
13907	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SVDFOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13908	auto _rank = _o->rank;
13909	auto _fused_activation_function = _o->fused_activation_function;
13910	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13911	return tflite::CreateSVDFOptions(
13912	_fbb,
13913	_rank,
13914	_fused_activation_function,
13915	_asymmetric_quantize_inputs);
13916	}
13917
13918	inline RNNOptionsT RNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13919	auto _o = std::unique_ptr<RNNOptionsT>(new RNNOptionsT ());
13920	UnPackTo(_o.get(), _resolver);
13921	return _o.release();
13922	}
13923
13924	inline void RNNOptions::UnPackTo(RNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13925	(void)_o;
13926	(void)_resolver;
13927	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13928	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13929	}
13930
13931	inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13932	return CreateRNNOptions(_fbb, _o, _rehasher);
13933	}
13934
13935	inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13936	(void)_rehasher;
13937	(void)_o;
13938	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13939	auto _fused_activation_function = _o->fused_activation_function;
13940	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13941	return tflite::CreateRNNOptions(
13942	_fbb,
13943	_fused_activation_function,
13944	_asymmetric_quantize_inputs);
13945	}
13946
13947	inline SequenceRNNOptionsT SequenceRNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13948	auto _o = std::unique_ptr<SequenceRNNOptionsT>(new SequenceRNNOptionsT ());
13949	UnPackTo(_o.get(), _resolver);
13950	return _o.release();
13951	}
13952
13953	inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13954	(void)_o;
13955	(void)_resolver;
13956	{ auto _e = time_major(); _o->time_major = _e; }
13957	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13958	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13959	}
13960
13961	inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13962	return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
13963	}
13964
13965	inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13966	(void)_rehasher;
13967	(void)_o;
13968	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
13969	auto _time_major = _o->time_major;
13970	auto _fused_activation_function = _o->fused_activation_function;
13971	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13972	return tflite::CreateSequenceRNNOptions(
13973	_fbb,
13974	_time_major,
13975	_fused_activation_function,
13976	_asymmetric_quantize_inputs);
13977	}
13978
13979	inline BidirectionalSequenceRNNOptionsT BidirectionalSequenceRNNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
13980	auto _o = std::unique_ptr<BidirectionalSequenceRNNOptionsT>(new BidirectionalSequenceRNNOptionsT ());
13981	UnPackTo(_o.get(), _resolver);
13982	return _o.release();
13983	}
13984
13985	inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
13986	(void)_o;
13987	(void)_resolver;
13988	{ auto _e = time_major(); _o->time_major = _e; }
13989	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13990	{ auto _e = merge_outputs(); _o->merge_outputs = _e; }
13991	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13992	}
13993
13994	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13995	return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
13996	}
13997
13998	inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
13999	(void)_rehasher;
14000	(void)_o;
14001	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14002	auto _time_major = _o->time_major;
14003	auto _fused_activation_function = _o->fused_activation_function;
14004	auto _merge_outputs = _o->merge_outputs;
14005	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14006	return tflite::CreateBidirectionalSequenceRNNOptions(
14007	_fbb,
14008	_time_major,
14009	_fused_activation_function,
14010	_merge_outputs,
14011	_asymmetric_quantize_inputs);
14012	}
14013
14014	inline FullyConnectedOptionsT FullyConnectedOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14015	auto _o = std::unique_ptr<FullyConnectedOptionsT>(new FullyConnectedOptionsT ());
14016	UnPackTo(_o.get(), _resolver);
14017	return _o.release();
14018	}
14019
14020	inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14021	(void)_o;
14022	(void)_resolver;
14023	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14024	{ auto _e = weights_format(); _o->weights_format = _e; }
14025	{ auto _e = keep_num_dims(); _o->keep_num_dims = _e; }
14026	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14027	}
14028
14029	inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14030	return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
14031	}
14032
14033	inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14034	(void)_rehasher;
14035	(void)_o;
14036	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14037	auto _fused_activation_function = _o->fused_activation_function;
14038	auto _weights_format = _o->weights_format;
14039	auto _keep_num_dims = _o->keep_num_dims;
14040	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14041	return tflite::CreateFullyConnectedOptions(
14042	_fbb,
14043	_fused_activation_function,
14044	_weights_format,
14045	_keep_num_dims,
14046	_asymmetric_quantize_inputs);
14047	}
14048
14049	inline SoftmaxOptionsT SoftmaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14050	auto _o = std::unique_ptr<SoftmaxOptionsT>(new SoftmaxOptionsT ());
14051	UnPackTo(_o.get(), _resolver);
14052	return _o.release();
14053	}
14054
14055	inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14056	(void)_o;
14057	(void)_resolver;
14058	{ auto _e = beta(); _o->beta = _e; }
14059	}
14060
14061	inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14062	return CreateSoftmaxOptions(_fbb, _o, _rehasher);
14063	}
14064
14065	inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14066	(void)_rehasher;
14067	(void)_o;
14068	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14069	auto _beta = _o->beta;
14070	return tflite::CreateSoftmaxOptions(
14071	_fbb,
14072	_beta);
14073	}
14074
14075	inline ConcatenationOptionsT ConcatenationOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14076	auto _o = std::unique_ptr<ConcatenationOptionsT>(new ConcatenationOptionsT ());
14077	UnPackTo(_o.get(), _resolver);
14078	return _o.release();
14079	}
14080
14081	inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14082	(void)_o;
14083	(void)_resolver;
14084	{ auto _e = axis(); _o->axis = _e; }
14085	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14086	}
14087
14088	inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14089	return CreateConcatenationOptions(_fbb, _o, _rehasher);
14090	}
14091
14092	inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14093	(void)_rehasher;
14094	(void)_o;
14095	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14096	auto _axis = _o->axis;
14097	auto _fused_activation_function = _o->fused_activation_function;
14098	return tflite::CreateConcatenationOptions(
14099	_fbb,
14100	_axis,
14101	_fused_activation_function);
14102	}
14103
14104	inline AddOptionsT AddOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14105	auto _o = std::unique_ptr<AddOptionsT>(new AddOptionsT ());
14106	UnPackTo(_o.get(), _resolver);
14107	return _o.release();
14108	}
14109
14110	inline void AddOptions::UnPackTo(AddOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14111	(void)_o;
14112	(void)_resolver;
14113	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14114	{ auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
14115	}
14116
14117	inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14118	return CreateAddOptions(_fbb, _o, _rehasher);
14119	}
14120
14121	inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14122	(void)_rehasher;
14123	(void)_o;
14124	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AddOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14125	auto _fused_activation_function = _o->fused_activation_function;
14126	auto _pot_scale_int16 = _o->pot_scale_int16;
14127	return tflite::CreateAddOptions(
14128	_fbb,
14129	_fused_activation_function,
14130	_pot_scale_int16);
14131	}
14132
14133	inline MulOptionsT MulOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14134	auto _o = std::unique_ptr<MulOptionsT>(new MulOptionsT ());
14135	UnPackTo(_o.get(), _resolver);
14136	return _o.release();
14137	}
14138
14139	inline void MulOptions::UnPackTo(MulOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14140	(void)_o;
14141	(void)_resolver;
14142	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14143	}
14144
14145	inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14146	return CreateMulOptions(_fbb, _o, _rehasher);
14147	}
14148
14149	inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14150	(void)_rehasher;
14151	(void)_o;
14152	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MulOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14153	auto _fused_activation_function = _o->fused_activation_function;
14154	return tflite::CreateMulOptions(
14155	_fbb,
14156	_fused_activation_function);
14157	}
14158
14159	inline L2NormOptionsT L2NormOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14160	auto _o = std::unique_ptr<L2NormOptionsT>(new L2NormOptionsT ());
14161	UnPackTo(_o.get(), _resolver);
14162	return _o.release();
14163	}
14164
14165	inline void L2NormOptions::UnPackTo(L2NormOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14166	(void)_o;
14167	(void)_resolver;
14168	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14169	}
14170
14171	inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14172	return CreateL2NormOptions(_fbb, _o, _rehasher);
14173	}
14174
14175	inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14176	(void)_rehasher;
14177	(void)_o;
14178	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* L2NormOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14179	auto _fused_activation_function = _o->fused_activation_function;
14180	return tflite::CreateL2NormOptions(
14181	_fbb,
14182	_fused_activation_function);
14183	}
14184
14185	inline LocalResponseNormalizationOptionsT LocalResponseNormalizationOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14186	auto _o = std::unique_ptr<LocalResponseNormalizationOptionsT>(new LocalResponseNormalizationOptionsT ());
14187	UnPackTo(_o.get(), _resolver);
14188	return _o.release();
14189	}
14190
14191	inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14192	(void)_o;
14193	(void)_resolver;
14194	{ auto _e = radius(); _o->radius = _e; }
14195	{ auto _e = bias(); _o->bias = _e; }
14196	{ auto _e = alpha(); _o->alpha = _e; }
14197	{ auto _e = beta(); _o->beta = _e; }
14198	}
14199
14200	inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14201	return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
14202	}
14203
14204	inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14205	(void)_rehasher;
14206	(void)_o;
14207	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14208	auto _radius = _o->radius;
14209	auto _bias = _o->bias;
14210	auto _alpha = _o->alpha;
14211	auto _beta = _o->beta;
14212	return tflite::CreateLocalResponseNormalizationOptions(
14213	_fbb,
14214	_radius,
14215	_bias,
14216	_alpha,
14217	_beta);
14218	}
14219
14220	inline LSTMOptionsT LSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14221	auto _o = std::unique_ptr<LSTMOptionsT>(new LSTMOptionsT ());
14222	UnPackTo(_o.get(), _resolver);
14223	return _o.release();
14224	}
14225
14226	inline void LSTMOptions::UnPackTo(LSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14227	(void)_o;
14228	(void)_resolver;
14229	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14230	{ auto _e = cell_clip(); _o->cell_clip = _e; }
14231	{ auto _e = proj_clip(); _o->proj_clip = _e; }
14232	{ auto _e = kernel_type(); _o->kernel_type = _e; }
14233	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14234	}
14235
14236	inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14237	return CreateLSTMOptions(_fbb, _o, _rehasher);
14238	}
14239
14240	inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14241	(void)_rehasher;
14242	(void)_o;
14243	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14244	auto _fused_activation_function = _o->fused_activation_function;
14245	auto _cell_clip = _o->cell_clip;
14246	auto _proj_clip = _o->proj_clip;
14247	auto _kernel_type = _o->kernel_type;
14248	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14249	return tflite::CreateLSTMOptions(
14250	_fbb,
14251	_fused_activation_function,
14252	_cell_clip,
14253	_proj_clip,
14254	_kernel_type,
14255	_asymmetric_quantize_inputs);
14256	}
14257
14258	inline UnidirectionalSequenceLSTMOptionsT UnidirectionalSequenceLSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14259	auto _o = std::unique_ptr<UnidirectionalSequenceLSTMOptionsT>(new UnidirectionalSequenceLSTMOptionsT ());
14260	UnPackTo(_o.get(), _resolver);
14261	return _o.release();
14262	}
14263
14264	inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14265	(void)_o;
14266	(void)_resolver;
14267	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14268	{ auto _e = cell_clip(); _o->cell_clip = _e; }
14269	{ auto _e = proj_clip(); _o->proj_clip = _e; }
14270	{ auto _e = time_major(); _o->time_major = _e; }
14271	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14272	}
14273
14274	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14275	return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
14276	}
14277
14278	inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14279	(void)_rehasher;
14280	(void)_o;
14281	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14282	auto _fused_activation_function = _o->fused_activation_function;
14283	auto _cell_clip = _o->cell_clip;
14284	auto _proj_clip = _o->proj_clip;
14285	auto _time_major = _o->time_major;
14286	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14287	return tflite::CreateUnidirectionalSequenceLSTMOptions(
14288	_fbb,
14289	_fused_activation_function,
14290	_cell_clip,
14291	_proj_clip,
14292	_time_major,
14293	_asymmetric_quantize_inputs);
14294	}
14295
14296	inline BidirectionalSequenceLSTMOptionsT BidirectionalSequenceLSTMOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14297	auto _o = std::unique_ptr<BidirectionalSequenceLSTMOptionsT>(new BidirectionalSequenceLSTMOptionsT ());
14298	UnPackTo(_o.get(), _resolver);
14299	return _o.release();
14300	}
14301
14302	inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14303	(void)_o;
14304	(void)_resolver;
14305	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14306	{ auto _e = cell_clip(); _o->cell_clip = _e; }
14307	{ auto _e = proj_clip(); _o->proj_clip = _e; }
14308	{ auto _e = merge_outputs(); _o->merge_outputs = _e; }
14309	{ auto _e = time_major(); _o->time_major = _e; }
14310	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14311	}
14312
14313	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14314	return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
14315	}
14316
14317	inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14318	(void)_rehasher;
14319	(void)_o;
14320	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14321	auto _fused_activation_function = _o->fused_activation_function;
14322	auto _cell_clip = _o->cell_clip;
14323	auto _proj_clip = _o->proj_clip;
14324	auto _merge_outputs = _o->merge_outputs;
14325	auto _time_major = _o->time_major;
14326	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14327	return tflite::CreateBidirectionalSequenceLSTMOptions(
14328	_fbb,
14329	_fused_activation_function,
14330	_cell_clip,
14331	_proj_clip,
14332	_merge_outputs,
14333	_time_major,
14334	_asymmetric_quantize_inputs);
14335	}
14336
14337	inline ResizeBilinearOptionsT ResizeBilinearOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14338	auto _o = std::unique_ptr<ResizeBilinearOptionsT>(new ResizeBilinearOptionsT ());
14339	UnPackTo(_o.get(), _resolver);
14340	return _o.release();
14341	}
14342
14343	inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14344	(void)_o;
14345	(void)_resolver;
14346	{ auto _e = align_corners(); _o->align_corners = _e; }
14347	{ auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
14348	}
14349
14350	inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14351	return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
14352	}
14353
14354	inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14355	(void)_rehasher;
14356	(void)_o;
14357	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14358	auto _align_corners = _o->align_corners;
14359	auto _half_pixel_centers = _o->half_pixel_centers;
14360	return tflite::CreateResizeBilinearOptions(
14361	_fbb,
14362	_align_corners,
14363	_half_pixel_centers);
14364	}
14365
14366	inline ResizeNearestNeighborOptionsT ResizeNearestNeighborOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14367	auto _o = std::unique_ptr<ResizeNearestNeighborOptionsT>(new ResizeNearestNeighborOptionsT ());
14368	UnPackTo(_o.get(), _resolver);
14369	return _o.release();
14370	}
14371
14372	inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14373	(void)_o;
14374	(void)_resolver;
14375	{ auto _e = align_corners(); _o->align_corners = _e; }
14376	{ auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
14377	}
14378
14379	inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14380	return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
14381	}
14382
14383	inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14384	(void)_rehasher;
14385	(void)_o;
14386	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14387	auto _align_corners = _o->align_corners;
14388	auto _half_pixel_centers = _o->half_pixel_centers;
14389	return tflite::CreateResizeNearestNeighborOptions(
14390	_fbb,
14391	_align_corners,
14392	_half_pixel_centers);
14393	}
14394
14395	inline CallOptionsT CallOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14396	auto _o = std::unique_ptr<CallOptionsT>(new CallOptionsT ());
14397	UnPackTo(_o.get(), _resolver);
14398	return _o.release();
14399	}
14400
14401	inline void CallOptions::UnPackTo(CallOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14402	(void)_o;
14403	(void)_resolver;
14404	{ auto _e = subgraph(); _o->subgraph = _e; }
14405	}
14406
14407	inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14408	return CreateCallOptions(_fbb, _o, _rehasher);
14409	}
14410
14411	inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14412	(void)_rehasher;
14413	(void)_o;
14414	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CallOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14415	auto _subgraph = _o->subgraph;
14416	return tflite::CreateCallOptions(
14417	_fbb,
14418	_subgraph);
14419	}
14420
14421	inline PadOptionsT PadOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14422	auto _o = std::unique_ptr<PadOptionsT>(new PadOptionsT ());
14423	UnPackTo(_o.get(), _resolver);
14424	return _o.release();
14425	}
14426
14427	inline void PadOptions::UnPackTo(PadOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14428	(void)_o;
14429	(void)_resolver;
14430	}
14431
14432	inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14433	return CreatePadOptions(_fbb, _o, _rehasher);
14434	}
14435
14436	inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14437	(void)_rehasher;
14438	(void)_o;
14439	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PadOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14440	return tflite::CreatePadOptions(
14441	_fbb);
14442	}
14443
14444	inline PadV2OptionsT PadV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14445	auto _o = std::unique_ptr<PadV2OptionsT>(new PadV2OptionsT ());
14446	UnPackTo(_o.get(), _resolver);
14447	return _o.release();
14448	}
14449
14450	inline void PadV2Options::UnPackTo(PadV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14451	(void)_o;
14452	(void)_resolver;
14453	}
14454
14455	inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14456	return CreatePadV2Options(_fbb, _o, _rehasher);
14457	}
14458
14459	inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14460	(void)_rehasher;
14461	(void)_o;
14462	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PadV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14463	return tflite::CreatePadV2Options(
14464	_fbb);
14465	}
14466
14467	inline ReshapeOptionsT ReshapeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14468	auto _o = std::unique_ptr<ReshapeOptionsT>(new ReshapeOptionsT ());
14469	UnPackTo(_o.get(), _resolver);
14470	return _o.release();
14471	}
14472
14473	inline void ReshapeOptions::UnPackTo(ReshapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14474	(void)_o;
14475	(void)_resolver;
14476	{ auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->new_shape [_i] = _e->Get(_i); } } }
14477	}
14478
14479	inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14480	return CreateReshapeOptions(_fbb, _o, _rehasher);
14481	}
14482
14483	inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14484	(void)_rehasher;
14485	(void)_o;
14486	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14487	auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : `0`;
14488	return tflite::CreateReshapeOptions(
14489	_fbb,
14490	_new_shape);
14491	}
14492
14493	inline SpaceToBatchNDOptionsT SpaceToBatchNDOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14494	auto _o = std::unique_ptr<SpaceToBatchNDOptionsT>(new SpaceToBatchNDOptionsT ());
14495	UnPackTo(_o.get(), _resolver);
14496	return _o.release();
14497	}
14498
14499	inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14500	(void)_o;
14501	(void)_resolver;
14502	}
14503
14504	inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14505	return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
14506	}
14507
14508	inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14509	(void)_rehasher;
14510	(void)_o;
14511	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14512	return tflite::CreateSpaceToBatchNDOptions(
14513	_fbb);
14514	}
14515
14516	inline BatchToSpaceNDOptionsT BatchToSpaceNDOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14517	auto _o = std::unique_ptr<BatchToSpaceNDOptionsT>(new BatchToSpaceNDOptionsT ());
14518	UnPackTo(_o.get(), _resolver);
14519	return _o.release();
14520	}
14521
14522	inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14523	(void)_o;
14524	(void)_resolver;
14525	}
14526
14527	inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14528	return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
14529	}
14530
14531	inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14532	(void)_rehasher;
14533	(void)_o;
14534	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14535	return tflite::CreateBatchToSpaceNDOptions(
14536	_fbb);
14537	}
14538
14539	inline SkipGramOptionsT SkipGramOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14540	auto _o = std::unique_ptr<SkipGramOptionsT>(new SkipGramOptionsT ());
14541	UnPackTo(_o.get(), _resolver);
14542	return _o.release();
14543	}
14544
14545	inline void SkipGramOptions::UnPackTo(SkipGramOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14546	(void)_o;
14547	(void)_resolver;
14548	{ auto _e = ngram_size(); _o->ngram_size = _e; }
14549	{ auto _e = max_skip_size(); _o->max_skip_size = _e; }
14550	{ auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }
14551	}
14552
14553	inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14554	return CreateSkipGramOptions(_fbb, _o, _rehasher);
14555	}
14556
14557	inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14558	(void)_rehasher;
14559	(void)_o;
14560	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14561	auto _ngram_size = _o->ngram_size;
14562	auto _max_skip_size = _o->max_skip_size;
14563	auto _include_all_ngrams = _o->include_all_ngrams;
14564	return tflite::CreateSkipGramOptions(
14565	_fbb,
14566	_ngram_size,
14567	_max_skip_size,
14568	_include_all_ngrams);
14569	}
14570
14571	inline SpaceToDepthOptionsT SpaceToDepthOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14572	auto _o = std::unique_ptr<SpaceToDepthOptionsT>(new SpaceToDepthOptionsT ());
14573	UnPackTo(_o.get(), _resolver);
14574	return _o.release();
14575	}
14576
14577	inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14578	(void)_o;
14579	(void)_resolver;
14580	{ auto _e = block_size(); _o->block_size = _e; }
14581	}
14582
14583	inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14584	return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
14585	}
14586
14587	inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14588	(void)_rehasher;
14589	(void)_o;
14590	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14591	auto _block_size = _o->block_size;
14592	return tflite::CreateSpaceToDepthOptions(
14593	_fbb,
14594	_block_size);
14595	}
14596
14597	inline DepthToSpaceOptionsT DepthToSpaceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14598	auto _o = std::unique_ptr<DepthToSpaceOptionsT>(new DepthToSpaceOptionsT ());
14599	UnPackTo(_o.get(), _resolver);
14600	return _o.release();
14601	}
14602
14603	inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14604	(void)_o;
14605	(void)_resolver;
14606	{ auto _e = block_size(); _o->block_size = _e; }
14607	}
14608
14609	inline flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14610	return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
14611	}
14612
14613	inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14614	(void)_rehasher;
14615	(void)_o;
14616	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14617	auto _block_size = _o->block_size;
14618	return tflite::CreateDepthToSpaceOptions(
14619	_fbb,
14620	_block_size);
14621	}
14622
14623	inline SubOptionsT SubOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14624	auto _o = std::unique_ptr<SubOptionsT>(new SubOptionsT ());
14625	UnPackTo(_o.get(), _resolver);
14626	return _o.release();
14627	}
14628
14629	inline void SubOptions::UnPackTo(SubOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14630	(void)_o;
14631	(void)_resolver;
14632	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14633	{ auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
14634	}
14635
14636	inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14637	return CreateSubOptions(_fbb, _o, _rehasher);
14638	}
14639
14640	inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14641	(void)_rehasher;
14642	(void)_o;
14643	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SubOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14644	auto _fused_activation_function = _o->fused_activation_function;
14645	auto _pot_scale_int16 = _o->pot_scale_int16;
14646	return tflite::CreateSubOptions(
14647	_fbb,
14648	_fused_activation_function,
14649	_pot_scale_int16);
14650	}
14651
14652	inline DivOptionsT DivOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14653	auto _o = std::unique_ptr<DivOptionsT>(new DivOptionsT ());
14654	UnPackTo(_o.get(), _resolver);
14655	return _o.release();
14656	}
14657
14658	inline void DivOptions::UnPackTo(DivOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14659	(void)_o;
14660	(void)_resolver;
14661	{ auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14662	}
14663
14664	inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14665	return CreateDivOptions(_fbb, _o, _rehasher);
14666	}
14667
14668	inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14669	(void)_rehasher;
14670	(void)_o;
14671	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DivOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14672	auto _fused_activation_function = _o->fused_activation_function;
14673	return tflite::CreateDivOptions(
14674	_fbb,
14675	_fused_activation_function);
14676	}
14677
14678	inline TopKV2OptionsT TopKV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14679	auto _o = std::unique_ptr<TopKV2OptionsT>(new TopKV2OptionsT ());
14680	UnPackTo(_o.get(), _resolver);
14681	return _o.release();
14682	}
14683
14684	inline void TopKV2Options::UnPackTo(TopKV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14685	(void)_o;
14686	(void)_resolver;
14687	}
14688
14689	inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14690	return CreateTopKV2Options(_fbb, _o, _rehasher);
14691	}
14692
14693	inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14694	(void)_rehasher;
14695	(void)_o;
14696	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14697	return tflite::CreateTopKV2Options(
14698	_fbb);
14699	}
14700
14701	inline EmbeddingLookupSparseOptionsT EmbeddingLookupSparseOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14702	auto _o = std::unique_ptr<EmbeddingLookupSparseOptionsT>(new EmbeddingLookupSparseOptionsT ());
14703	UnPackTo(_o.get(), _resolver);
14704	return _o.release();
14705	}
14706
14707	inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14708	(void)_o;
14709	(void)_resolver;
14710	{ auto _e = combiner(); _o->combiner = _e; }
14711	}
14712
14713	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14714	return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
14715	}
14716
14717	inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14718	(void)_rehasher;
14719	(void)_o;
14720	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14721	auto _combiner = _o->combiner;
14722	return tflite::CreateEmbeddingLookupSparseOptions(
14723	_fbb,
14724	_combiner);
14725	}
14726
14727	inline GatherOptionsT GatherOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14728	auto _o = std::unique_ptr<GatherOptionsT>(new GatherOptionsT ());
14729	UnPackTo(_o.get(), _resolver);
14730	return _o.release();
14731	}
14732
14733	inline void GatherOptions::UnPackTo(GatherOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14734	(void)_o;
14735	(void)_resolver;
14736	{ auto _e = axis(); _o->axis = _e; }
14737	{ auto _e = batch_dims(); _o->batch_dims = _e; }
14738	}
14739
14740	inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14741	return CreateGatherOptions(_fbb, _o, _rehasher);
14742	}
14743
14744	inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14745	(void)_rehasher;
14746	(void)_o;
14747	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GatherOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14748	auto _axis = _o->axis;
14749	auto _batch_dims = _o->batch_dims;
14750	return tflite::CreateGatherOptions(
14751	_fbb,
14752	_axis,
14753	_batch_dims);
14754	}
14755
14756	inline TransposeOptionsT TransposeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14757	auto _o = std::unique_ptr<TransposeOptionsT>(new TransposeOptionsT ());
14758	UnPackTo(_o.get(), _resolver);
14759	return _o.release();
14760	}
14761
14762	inline void TransposeOptions::UnPackTo(TransposeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14763	(void)_o;
14764	(void)_resolver;
14765	}
14766
14767	inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14768	return CreateTransposeOptions(_fbb, _o, _rehasher);
14769	}
14770
14771	inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14772	(void)_rehasher;
14773	(void)_o;
14774	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TransposeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14775	return tflite::CreateTransposeOptions(
14776	_fbb);
14777	}
14778
14779	inline ExpOptionsT ExpOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14780	auto _o = std::unique_ptr<ExpOptionsT>(new ExpOptionsT ());
14781	UnPackTo(_o.get(), _resolver);
14782	return _o.release();
14783	}
14784
14785	inline void ExpOptions::UnPackTo(ExpOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14786	(void)_o;
14787	(void)_resolver;
14788	}
14789
14790	inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14791	return CreateExpOptions(_fbb, _o, _rehasher);
14792	}
14793
14794	inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14795	(void)_rehasher;
14796	(void)_o;
14797	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ExpOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14798	return tflite::CreateExpOptions(
14799	_fbb);
14800	}
14801
14802	inline CosOptionsT CosOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14803	auto _o = std::unique_ptr<CosOptionsT>(new CosOptionsT ());
14804	UnPackTo(_o.get(), _resolver);
14805	return _o.release();
14806	}
14807
14808	inline void CosOptions::UnPackTo(CosOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14809	(void)_o;
14810	(void)_resolver;
14811	}
14812
14813	inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14814	return CreateCosOptions(_fbb, _o, _rehasher);
14815	}
14816
14817	inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14818	(void)_rehasher;
14819	(void)_o;
14820	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CosOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14821	return tflite::CreateCosOptions(
14822	_fbb);
14823	}
14824
14825	inline ReducerOptionsT ReducerOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14826	auto _o = std::unique_ptr<ReducerOptionsT>(new ReducerOptionsT ());
14827	UnPackTo(_o.get(), _resolver);
14828	return _o.release();
14829	}
14830
14831	inline void ReducerOptions::UnPackTo(ReducerOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14832	(void)_o;
14833	(void)_resolver;
14834	{ auto _e = keep_dims(); _o->keep_dims = _e; }
14835	}
14836
14837	inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14838	return CreateReducerOptions(_fbb, _o, _rehasher);
14839	}
14840
14841	inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14842	(void)_rehasher;
14843	(void)_o;
14844	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReducerOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14845	auto _keep_dims = _o->keep_dims;
14846	return tflite::CreateReducerOptions(
14847	_fbb,
14848	_keep_dims);
14849	}
14850
14851	inline SqueezeOptionsT SqueezeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14852	auto _o = std::unique_ptr<SqueezeOptionsT>(new SqueezeOptionsT ());
14853	UnPackTo(_o.get(), _resolver);
14854	return _o.release();
14855	}
14856
14857	inline void SqueezeOptions::UnPackTo(SqueezeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14858	(void)_o;
14859	(void)_resolver;
14860	{ auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->squeeze_dims [_i] = _e->Get(_i); } } }
14861	}
14862
14863	inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14864	return CreateSqueezeOptions(_fbb, _o, _rehasher);
14865	}
14866
14867	inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14868	(void)_rehasher;
14869	(void)_o;
14870	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14871	auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : `0`;
14872	return tflite::CreateSqueezeOptions(
14873	_fbb,
14874	_squeeze_dims);
14875	}
14876
14877	inline SplitOptionsT SplitOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14878	auto _o = std::unique_ptr<SplitOptionsT>(new SplitOptionsT ());
14879	UnPackTo(_o.get(), _resolver);
14880	return _o.release();
14881	}
14882
14883	inline void SplitOptions::UnPackTo(SplitOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14884	(void)_o;
14885	(void)_resolver;
14886	{ auto _e = num_splits(); _o->num_splits = _e; }
14887	}
14888
14889	inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14890	return CreateSplitOptions(_fbb, _o, _rehasher);
14891	}
14892
14893	inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14894	(void)_rehasher;
14895	(void)_o;
14896	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SplitOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14897	auto _num_splits = _o->num_splits;
14898	return tflite::CreateSplitOptions(
14899	_fbb,
14900	_num_splits);
14901	}
14902
14903	inline SplitVOptionsT SplitVOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14904	auto _o = std::unique_ptr<SplitVOptionsT>(new SplitVOptionsT ());
14905	UnPackTo(_o.get(), _resolver);
14906	return _o.release();
14907	}
14908
14909	inline void SplitVOptions::UnPackTo(SplitVOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14910	(void)_o;
14911	(void)_resolver;
14912	{ auto _e = num_splits(); _o->num_splits = _e; }
14913	}
14914
14915	inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14916	return CreateSplitVOptions(_fbb, _o, _rehasher);
14917	}
14918
14919	inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14920	(void)_rehasher;
14921	(void)_o;
14922	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SplitVOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14923	auto _num_splits = _o->num_splits;
14924	return tflite::CreateSplitVOptions(
14925	_fbb,
14926	_num_splits);
14927	}
14928
14929	inline StridedSliceOptionsT StridedSliceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14930	auto _o = std::unique_ptr<StridedSliceOptionsT>(new StridedSliceOptionsT ());
14931	UnPackTo(_o.get(), _resolver);
14932	return _o.release();
14933	}
14934
14935	inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14936	(void)_o;
14937	(void)_resolver;
14938	{ auto _e = begin_mask(); _o->begin_mask = _e; }
14939	{ auto _e = end_mask(); _o->end_mask = _e; }
14940	{ auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; }
14941	{ auto _e = new_axis_mask(); _o->new_axis_mask = _e; }
14942	{ auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; }
14943	}
14944
14945	inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14946	return CreateStridedSliceOptions(_fbb, _o, _rehasher);
14947	}
14948
14949	inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14950	(void)_rehasher;
14951	(void)_o;
14952	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14953	auto _begin_mask = _o->begin_mask;
14954	auto _end_mask = _o->end_mask;
14955	auto _ellipsis_mask = _o->ellipsis_mask;
14956	auto _new_axis_mask = _o->new_axis_mask;
14957	auto _shrink_axis_mask = _o->shrink_axis_mask;
14958	return tflite::CreateStridedSliceOptions(
14959	_fbb,
14960	_begin_mask,
14961	_end_mask,
14962	_ellipsis_mask,
14963	_new_axis_mask,
14964	_shrink_axis_mask);
14965	}
14966
14967	inline LogSoftmaxOptionsT LogSoftmaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14968	auto _o = std::unique_ptr<LogSoftmaxOptionsT>(new LogSoftmaxOptionsT ());
14969	UnPackTo(_o.get(), _resolver);
14970	return _o.release();
14971	}
14972
14973	inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14974	(void)_o;
14975	(void)_resolver;
14976	}
14977
14978	inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14979	return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
14980	}
14981
14982	inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
14983	(void)_rehasher;
14984	(void)_o;
14985	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
14986	return tflite::CreateLogSoftmaxOptions(
14987	_fbb);
14988	}
14989
14990	inline CastOptionsT CastOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
14991	auto _o = std::unique_ptr<CastOptionsT>(new CastOptionsT ());
14992	UnPackTo(_o.get(), _resolver);
14993	return _o.release();
14994	}
14995
14996	inline void CastOptions::UnPackTo(CastOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
14997	(void)_o;
14998	(void)_resolver;
14999	{ auto _e = in_data_type(); _o->in_data_type = _e; }
15000	{ auto _e = out_data_type(); _o->out_data_type = _e; }
15001	}
15002
15003	inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15004	return CreateCastOptions(_fbb, _o, _rehasher);
15005	}
15006
15007	inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15008	(void)_rehasher;
15009	(void)_o;
15010	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CastOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15011	auto _in_data_type = _o->in_data_type;
15012	auto _out_data_type = _o->out_data_type;
15013	return tflite::CreateCastOptions(
15014	_fbb,
15015	_in_data_type,
15016	_out_data_type);
15017	}
15018
15019	inline DequantizeOptionsT DequantizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15020	auto _o = std::unique_ptr<DequantizeOptionsT>(new DequantizeOptionsT ());
15021	UnPackTo(_o.get(), _resolver);
15022	return _o.release();
15023	}
15024
15025	inline void DequantizeOptions::UnPackTo(DequantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15026	(void)_o;
15027	(void)_resolver;
15028	}
15029
15030	inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15031	return CreateDequantizeOptions(_fbb, _o, _rehasher);
15032	}
15033
15034	inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15035	(void)_rehasher;
15036	(void)_o;
15037	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15038	return tflite::CreateDequantizeOptions(
15039	_fbb);
15040	}
15041
15042	inline MaximumMinimumOptionsT MaximumMinimumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15043	auto _o = std::unique_ptr<MaximumMinimumOptionsT>(new MaximumMinimumOptionsT ());
15044	UnPackTo(_o.get(), _resolver);
15045	return _o.release();
15046	}
15047
15048	inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15049	(void)_o;
15050	(void)_resolver;
15051	}
15052
15053	inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15054	return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
15055	}
15056
15057	inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15058	(void)_rehasher;
15059	(void)_o;
15060	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15061	return tflite::CreateMaximumMinimumOptions(
15062	_fbb);
15063	}
15064
15065	inline TileOptionsT TileOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15066	auto _o = std::unique_ptr<TileOptionsT>(new TileOptionsT ());
15067	UnPackTo(_o.get(), _resolver);
15068	return _o.release();
15069	}
15070
15071	inline void TileOptions::UnPackTo(TileOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15072	(void)_o;
15073	(void)_resolver;
15074	}
15075
15076	inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15077	return CreateTileOptions(_fbb, _o, _rehasher);
15078	}
15079
15080	inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15081	(void)_rehasher;
15082	(void)_o;
15083	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TileOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15084	return tflite::CreateTileOptions(
15085	_fbb);
15086	}
15087
15088	inline ArgMaxOptionsT ArgMaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15089	auto _o = std::unique_ptr<ArgMaxOptionsT>(new ArgMaxOptionsT ());
15090	UnPackTo(_o.get(), _resolver);
15091	return _o.release();
15092	}
15093
15094	inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15095	(void)_o;
15096	(void)_resolver;
15097	{ auto _e = output_type(); _o->output_type = _e; }
15098	}
15099
15100	inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15101	return CreateArgMaxOptions(_fbb, _o, _rehasher);
15102	}
15103
15104	inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15105	(void)_rehasher;
15106	(void)_o;
15107	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15108	auto _output_type = _o->output_type;
15109	return tflite::CreateArgMaxOptions(
15110	_fbb,
15111	_output_type);
15112	}
15113
15114	inline ArgMinOptionsT ArgMinOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15115	auto _o = std::unique_ptr<ArgMinOptionsT>(new ArgMinOptionsT ());
15116	UnPackTo(_o.get(), _resolver);
15117	return _o.release();
15118	}
15119
15120	inline void ArgMinOptions::UnPackTo(ArgMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15121	(void)_o;
15122	(void)_resolver;
15123	{ auto _e = output_type(); _o->output_type = _e; }
15124	}
15125
15126	inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15127	return CreateArgMinOptions(_fbb, _o, _rehasher);
15128	}
15129
15130	inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15131	(void)_rehasher;
15132	(void)_o;
15133	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15134	auto _output_type = _o->output_type;
15135	return tflite::CreateArgMinOptions(
15136	_fbb,
15137	_output_type);
15138	}
15139
15140	inline GreaterOptionsT GreaterOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15141	auto _o = std::unique_ptr<GreaterOptionsT>(new GreaterOptionsT ());
15142	UnPackTo(_o.get(), _resolver);
15143	return _o.release();
15144	}
15145
15146	inline void GreaterOptions::UnPackTo(GreaterOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15147	(void)_o;
15148	(void)_resolver;
15149	}
15150
15151	inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15152	return CreateGreaterOptions(_fbb, _o, _rehasher);
15153	}
15154
15155	inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15156	(void)_rehasher;
15157	(void)_o;
15158	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GreaterOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15159	return tflite::CreateGreaterOptions(
15160	_fbb);
15161	}
15162
15163	inline GreaterEqualOptionsT GreaterEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15164	auto _o = std::unique_ptr<GreaterEqualOptionsT>(new GreaterEqualOptionsT ());
15165	UnPackTo(_o.get(), _resolver);
15166	return _o.release();
15167	}
15168
15169	inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15170	(void)_o;
15171	(void)_resolver;
15172	}
15173
15174	inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15175	return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
15176	}
15177
15178	inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15179	(void)_rehasher;
15180	(void)_o;
15181	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15182	return tflite::CreateGreaterEqualOptions(
15183	_fbb);
15184	}
15185
15186	inline LessOptionsT LessOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15187	auto _o = std::unique_ptr<LessOptionsT>(new LessOptionsT ());
15188	UnPackTo(_o.get(), _resolver);
15189	return _o.release();
15190	}
15191
15192	inline void LessOptions::UnPackTo(LessOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15193	(void)_o;
15194	(void)_resolver;
15195	}
15196
15197	inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15198	return CreateLessOptions(_fbb, _o, _rehasher);
15199	}
15200
15201	inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15202	(void)_rehasher;
15203	(void)_o;
15204	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LessOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15205	return tflite::CreateLessOptions(
15206	_fbb);
15207	}
15208
15209	inline LessEqualOptionsT LessEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15210	auto _o = std::unique_ptr<LessEqualOptionsT>(new LessEqualOptionsT ());
15211	UnPackTo(_o.get(), _resolver);
15212	return _o.release();
15213	}
15214
15215	inline void LessEqualOptions::UnPackTo(LessEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15216	(void)_o;
15217	(void)_resolver;
15218	}
15219
15220	inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15221	return CreateLessEqualOptions(_fbb, _o, _rehasher);
15222	}
15223
15224	inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15225	(void)_rehasher;
15226	(void)_o;
15227	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15228	return tflite::CreateLessEqualOptions(
15229	_fbb);
15230	}
15231
15232	inline NegOptionsT NegOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15233	auto _o = std::unique_ptr<NegOptionsT>(new NegOptionsT ());
15234	UnPackTo(_o.get(), _resolver);
15235	return _o.release();
15236	}
15237
15238	inline void NegOptions::UnPackTo(NegOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15239	(void)_o;
15240	(void)_resolver;
15241	}
15242
15243	inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15244	return CreateNegOptions(_fbb, _o, _rehasher);
15245	}
15246
15247	inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15248	(void)_rehasher;
15249	(void)_o;
15250	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NegOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15251	return tflite::CreateNegOptions(
15252	_fbb);
15253	}
15254
15255	inline SelectOptionsT SelectOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15256	auto _o = std::unique_ptr<SelectOptionsT>(new SelectOptionsT ());
15257	UnPackTo(_o.get(), _resolver);
15258	return _o.release();
15259	}
15260
15261	inline void SelectOptions::UnPackTo(SelectOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15262	(void)_o;
15263	(void)_resolver;
15264	}
15265
15266	inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15267	return CreateSelectOptions(_fbb, _o, _rehasher);
15268	}
15269
15270	inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15271	(void)_rehasher;
15272	(void)_o;
15273	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SelectOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15274	return tflite::CreateSelectOptions(
15275	_fbb);
15276	}
15277
15278	inline SliceOptionsT SliceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15279	auto _o = std::unique_ptr<SliceOptionsT>(new SliceOptionsT ());
15280	UnPackTo(_o.get(), _resolver);
15281	return _o.release();
15282	}
15283
15284	inline void SliceOptions::UnPackTo(SliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15285	(void)_o;
15286	(void)_resolver;
15287	}
15288
15289	inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15290	return CreateSliceOptions(_fbb, _o, _rehasher);
15291	}
15292
15293	inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15294	(void)_rehasher;
15295	(void)_o;
15296	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SliceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15297	return tflite::CreateSliceOptions(
15298	_fbb);
15299	}
15300
15301	inline TransposeConvOptionsT TransposeConvOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15302	auto _o = std::unique_ptr<TransposeConvOptionsT>(new TransposeConvOptionsT ());
15303	UnPackTo(_o.get(), _resolver);
15304	return _o.release();
15305	}
15306
15307	inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15308	(void)_o;
15309	(void)_resolver;
15310	{ auto _e = padding(); _o->padding = _e; }
15311	{ auto _e = stride_w(); _o->stride_w = _e; }
15312	{ auto _e = stride_h(); _o->stride_h = _e; }
15313	}
15314
15315	inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15316	return CreateTransposeConvOptions(_fbb, _o, _rehasher);
15317	}
15318
15319	inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15320	(void)_rehasher;
15321	(void)_o;
15322	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15323	auto _padding = _o->padding;
15324	auto _stride_w = _o->stride_w;
15325	auto _stride_h = _o->stride_h;
15326	return tflite::CreateTransposeConvOptions(
15327	_fbb,
15328	_padding,
15329	_stride_w,
15330	_stride_h);
15331	}
15332
15333	inline ExpandDimsOptionsT ExpandDimsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15334	auto _o = std::unique_ptr<ExpandDimsOptionsT>(new ExpandDimsOptionsT ());
15335	UnPackTo(_o.get(), _resolver);
15336	return _o.release();
15337	}
15338
15339	inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15340	(void)_o;
15341	(void)_resolver;
15342	}
15343
15344	inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15345	return CreateExpandDimsOptions(_fbb, _o, _rehasher);
15346	}
15347
15348	inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15349	(void)_rehasher;
15350	(void)_o;
15351	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15352	return tflite::CreateExpandDimsOptions(
15353	_fbb);
15354	}
15355
15356	inline SparseToDenseOptionsT SparseToDenseOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15357	auto _o = std::unique_ptr<SparseToDenseOptionsT>(new SparseToDenseOptionsT ());
15358	UnPackTo(_o.get(), _resolver);
15359	return _o.release();
15360	}
15361
15362	inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15363	(void)_o;
15364	(void)_resolver;
15365	{ auto _e = validate_indices(); _o->validate_indices = _e; }
15366	}
15367
15368	inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15369	return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
15370	}
15371
15372	inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15373	(void)_rehasher;
15374	(void)_o;
15375	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15376	auto _validate_indices = _o->validate_indices;
15377	return tflite::CreateSparseToDenseOptions(
15378	_fbb,
15379	_validate_indices);
15380	}
15381
15382	inline EqualOptionsT EqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15383	auto _o = std::unique_ptr<EqualOptionsT>(new EqualOptionsT ());
15384	UnPackTo(_o.get(), _resolver);
15385	return _o.release();
15386	}
15387
15388	inline void EqualOptions::UnPackTo(EqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15389	(void)_o;
15390	(void)_resolver;
15391	}
15392
15393	inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15394	return CreateEqualOptions(_fbb, _o, _rehasher);
15395	}
15396
15397	inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15398	(void)_rehasher;
15399	(void)_o;
15400	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* EqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15401	return tflite::CreateEqualOptions(
15402	_fbb);
15403	}
15404
15405	inline NotEqualOptionsT NotEqualOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15406	auto _o = std::unique_ptr<NotEqualOptionsT>(new NotEqualOptionsT ());
15407	UnPackTo(_o.get(), _resolver);
15408	return _o.release();
15409	}
15410
15411	inline void NotEqualOptions::UnPackTo(NotEqualOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15412	(void)_o;
15413	(void)_resolver;
15414	}
15415
15416	inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15417	return CreateNotEqualOptions(_fbb, _o, _rehasher);
15418	}
15419
15420	inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15421	(void)_rehasher;
15422	(void)_o;
15423	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15424	return tflite::CreateNotEqualOptions(
15425	_fbb);
15426	}
15427
15428	inline ShapeOptionsT ShapeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15429	auto _o = std::unique_ptr<ShapeOptionsT>(new ShapeOptionsT ());
15430	UnPackTo(_o.get(), _resolver);
15431	return _o.release();
15432	}
15433
15434	inline void ShapeOptions::UnPackTo(ShapeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15435	(void)_o;
15436	(void)_resolver;
15437	{ auto _e = out_type(); _o->out_type = _e; }
15438	}
15439
15440	inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15441	return CreateShapeOptions(_fbb, _o, _rehasher);
15442	}
15443
15444	inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15445	(void)_rehasher;
15446	(void)_o;
15447	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ShapeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15448	auto _out_type = _o->out_type;
15449	return tflite::CreateShapeOptions(
15450	_fbb,
15451	_out_type);
15452	}
15453
15454	inline RankOptionsT RankOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15455	auto _o = std::unique_ptr<RankOptionsT>(new RankOptionsT ());
15456	UnPackTo(_o.get(), _resolver);
15457	return _o.release();
15458	}
15459
15460	inline void RankOptions::UnPackTo(RankOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15461	(void)_o;
15462	(void)_resolver;
15463	}
15464
15465	inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15466	return CreateRankOptions(_fbb, _o, _rehasher);
15467	}
15468
15469	inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15470	(void)_rehasher;
15471	(void)_o;
15472	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RankOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15473	return tflite::CreateRankOptions(
15474	_fbb);
15475	}
15476
15477	inline PowOptionsT PowOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15478	auto _o = std::unique_ptr<PowOptionsT>(new PowOptionsT ());
15479	UnPackTo(_o.get(), _resolver);
15480	return _o.release();
15481	}
15482
15483	inline void PowOptions::UnPackTo(PowOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15484	(void)_o;
15485	(void)_resolver;
15486	}
15487
15488	inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15489	return CreatePowOptions(_fbb, _o, _rehasher);
15490	}
15491
15492	inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15493	(void)_rehasher;
15494	(void)_o;
15495	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PowOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15496	return tflite::CreatePowOptions(
15497	_fbb);
15498	}
15499
15500	inline FakeQuantOptionsT FakeQuantOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15501	auto _o = std::unique_ptr<FakeQuantOptionsT>(new FakeQuantOptionsT ());
15502	UnPackTo(_o.get(), _resolver);
15503	return _o.release();
15504	}
15505
15506	inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15507	(void)_o;
15508	(void)_resolver;
15509	{ auto _e = min(); _o->min = _e; }
15510	{ auto _e = max(); _o->max = _e; }
15511	{ auto _e = num_bits(); _o->num_bits = _e; }
15512	{ auto _e = narrow_range(); _o->narrow_range = _e; }
15513	}
15514
15515	inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15516	return CreateFakeQuantOptions(_fbb, _o, _rehasher);
15517	}
15518
15519	inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15520	(void)_rehasher;
15521	(void)_o;
15522	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15523	auto _min = _o->min;
15524	auto _max = _o->max;
15525	auto _num_bits = _o->num_bits;
15526	auto _narrow_range = _o->narrow_range;
15527	return tflite::CreateFakeQuantOptions(
15528	_fbb,
15529	_min,
15530	_max,
15531	_num_bits,
15532	_narrow_range);
15533	}
15534
15535	inline PackOptionsT PackOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15536	auto _o = std::unique_ptr<PackOptionsT>(new PackOptionsT ());
15537	UnPackTo(_o.get(), _resolver);
15538	return _o.release();
15539	}
15540
15541	inline void PackOptions::UnPackTo(PackOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15542	(void)_o;
15543	(void)_resolver;
15544	{ auto _e = values_count(); _o->values_count = _e; }
15545	{ auto _e = axis(); _o->axis = _e; }
15546	}
15547
15548	inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15549	return CreatePackOptions(_fbb, _o, _rehasher);
15550	}
15551
15552	inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15553	(void)_rehasher;
15554	(void)_o;
15555	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* PackOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15556	auto _values_count = _o->values_count;
15557	auto _axis = _o->axis;
15558	return tflite::CreatePackOptions(
15559	_fbb,
15560	_values_count,
15561	_axis);
15562	}
15563
15564	inline LogicalOrOptionsT LogicalOrOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15565	auto _o = std::unique_ptr<LogicalOrOptionsT>(new LogicalOrOptionsT ());
15566	UnPackTo(_o.get(), _resolver);
15567	return _o.release();
15568	}
15569
15570	inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15571	(void)_o;
15572	(void)_resolver;
15573	}
15574
15575	inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15576	return CreateLogicalOrOptions(_fbb, _o, _rehasher);
15577	}
15578
15579	inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15580	(void)_rehasher;
15581	(void)_o;
15582	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15583	return tflite::CreateLogicalOrOptions(
15584	_fbb);
15585	}
15586
15587	inline OneHotOptionsT OneHotOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15588	auto _o = std::unique_ptr<OneHotOptionsT>(new OneHotOptionsT ());
15589	UnPackTo(_o.get(), _resolver);
15590	return _o.release();
15591	}
15592
15593	inline void OneHotOptions::UnPackTo(OneHotOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15594	(void)_o;
15595	(void)_resolver;
15596	{ auto _e = axis(); _o->axis = _e; }
15597	}
15598
15599	inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15600	return CreateOneHotOptions(_fbb, _o, _rehasher);
15601	}
15602
15603	inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15604	(void)_rehasher;
15605	(void)_o;
15606	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OneHotOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15607	auto _axis = _o->axis;
15608	return tflite::CreateOneHotOptions(
15609	_fbb,
15610	_axis);
15611	}
15612
15613	inline AbsOptionsT AbsOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15614	auto _o = std::unique_ptr<AbsOptionsT>(new AbsOptionsT ());
15615	UnPackTo(_o.get(), _resolver);
15616	return _o.release();
15617	}
15618
15619	inline void AbsOptions::UnPackTo(AbsOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15620	(void)_o;
15621	(void)_resolver;
15622	}
15623
15624	inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15625	return CreateAbsOptions(_fbb, _o, _rehasher);
15626	}
15627
15628	inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15629	(void)_rehasher;
15630	(void)_o;
15631	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AbsOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15632	return tflite::CreateAbsOptions(
15633	_fbb);
15634	}
15635
15636	inline HardSwishOptionsT HardSwishOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15637	auto _o = std::unique_ptr<HardSwishOptionsT>(new HardSwishOptionsT ());
15638	UnPackTo(_o.get(), _resolver);
15639	return _o.release();
15640	}
15641
15642	inline void HardSwishOptions::UnPackTo(HardSwishOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15643	(void)_o;
15644	(void)_resolver;
15645	}
15646
15647	inline flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15648	return CreateHardSwishOptions(_fbb, _o, _rehasher);
15649	}
15650
15651	inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15652	(void)_rehasher;
15653	(void)_o;
15654	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15655	return tflite::CreateHardSwishOptions(
15656	_fbb);
15657	}
15658
15659	inline LogicalAndOptionsT LogicalAndOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15660	auto _o = std::unique_ptr<LogicalAndOptionsT>(new LogicalAndOptionsT ());
15661	UnPackTo(_o.get(), _resolver);
15662	return _o.release();
15663	}
15664
15665	inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15666	(void)_o;
15667	(void)_resolver;
15668	}
15669
15670	inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15671	return CreateLogicalAndOptions(_fbb, _o, _rehasher);
15672	}
15673
15674	inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15675	(void)_rehasher;
15676	(void)_o;
15677	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15678	return tflite::CreateLogicalAndOptions(
15679	_fbb);
15680	}
15681
15682	inline LogicalNotOptionsT LogicalNotOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15683	auto _o = std::unique_ptr<LogicalNotOptionsT>(new LogicalNotOptionsT ());
15684	UnPackTo(_o.get(), _resolver);
15685	return _o.release();
15686	}
15687
15688	inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15689	(void)_o;
15690	(void)_resolver;
15691	}
15692
15693	inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15694	return CreateLogicalNotOptions(_fbb, _o, _rehasher);
15695	}
15696
15697	inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15698	(void)_rehasher;
15699	(void)_o;
15700	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15701	return tflite::CreateLogicalNotOptions(
15702	_fbb);
15703	}
15704
15705	inline UnpackOptionsT UnpackOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15706	auto _o = std::unique_ptr<UnpackOptionsT>(new UnpackOptionsT ());
15707	UnPackTo(_o.get(), _resolver);
15708	return _o.release();
15709	}
15710
15711	inline void UnpackOptions::UnPackTo(UnpackOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15712	(void)_o;
15713	(void)_resolver;
15714	{ auto _e = num(); _o->num = _e; }
15715	{ auto _e = axis(); _o->axis = _e; }
15716	}
15717
15718	inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15719	return CreateUnpackOptions(_fbb, _o, _rehasher);
15720	}
15721
15722	inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15723	(void)_rehasher;
15724	(void)_o;
15725	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnpackOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15726	auto _num = _o->num;
15727	auto _axis = _o->axis;
15728	return tflite::CreateUnpackOptions(
15729	_fbb,
15730	_num,
15731	_axis);
15732	}
15733
15734	inline FloorDivOptionsT FloorDivOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15735	auto _o = std::unique_ptr<FloorDivOptionsT>(new FloorDivOptionsT ());
15736	UnPackTo(_o.get(), _resolver);
15737	return _o.release();
15738	}
15739
15740	inline void FloorDivOptions::UnPackTo(FloorDivOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15741	(void)_o;
15742	(void)_resolver;
15743	}
15744
15745	inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15746	return CreateFloorDivOptions(_fbb, _o, _rehasher);
15747	}
15748
15749	inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15750	(void)_rehasher;
15751	(void)_o;
15752	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15753	return tflite::CreateFloorDivOptions(
15754	_fbb);
15755	}
15756
15757	inline SquareOptionsT SquareOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15758	auto _o = std::unique_ptr<SquareOptionsT>(new SquareOptionsT ());
15759	UnPackTo(_o.get(), _resolver);
15760	return _o.release();
15761	}
15762
15763	inline void SquareOptions::UnPackTo(SquareOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15764	(void)_o;
15765	(void)_resolver;
15766	}
15767
15768	inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15769	return CreateSquareOptions(_fbb, _o, _rehasher);
15770	}
15771
15772	inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15773	(void)_rehasher;
15774	(void)_o;
15775	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SquareOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15776	return tflite::CreateSquareOptions(
15777	_fbb);
15778	}
15779
15780	inline ZerosLikeOptionsT ZerosLikeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15781	auto _o = std::unique_ptr<ZerosLikeOptionsT>(new ZerosLikeOptionsT ());
15782	UnPackTo(_o.get(), _resolver);
15783	return _o.release();
15784	}
15785
15786	inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15787	(void)_o;
15788	(void)_resolver;
15789	}
15790
15791	inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15792	return CreateZerosLikeOptions(_fbb, _o, _rehasher);
15793	}
15794
15795	inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15796	(void)_rehasher;
15797	(void)_o;
15798	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15799	return tflite::CreateZerosLikeOptions(
15800	_fbb);
15801	}
15802
15803	inline FillOptionsT FillOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15804	auto _o = std::unique_ptr<FillOptionsT>(new FillOptionsT ());
15805	UnPackTo(_o.get(), _resolver);
15806	return _o.release();
15807	}
15808
15809	inline void FillOptions::UnPackTo(FillOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15810	(void)_o;
15811	(void)_resolver;
15812	}
15813
15814	inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15815	return CreateFillOptions(_fbb, _o, _rehasher);
15816	}
15817
15818	inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15819	(void)_rehasher;
15820	(void)_o;
15821	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FillOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15822	return tflite::CreateFillOptions(
15823	_fbb);
15824	}
15825
15826	inline FloorModOptionsT FloorModOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15827	auto _o = std::unique_ptr<FloorModOptionsT>(new FloorModOptionsT ());
15828	UnPackTo(_o.get(), _resolver);
15829	return _o.release();
15830	}
15831
15832	inline void FloorModOptions::UnPackTo(FloorModOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15833	(void)_o;
15834	(void)_resolver;
15835	}
15836
15837	inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15838	return CreateFloorModOptions(_fbb, _o, _rehasher);
15839	}
15840
15841	inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15842	(void)_rehasher;
15843	(void)_o;
15844	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* FloorModOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15845	return tflite::CreateFloorModOptions(
15846	_fbb);
15847	}
15848
15849	inline RangeOptionsT RangeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15850	auto _o = std::unique_ptr<RangeOptionsT>(new RangeOptionsT ());
15851	UnPackTo(_o.get(), _resolver);
15852	return _o.release();
15853	}
15854
15855	inline void RangeOptions::UnPackTo(RangeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15856	(void)_o;
15857	(void)_resolver;
15858	}
15859
15860	inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15861	return CreateRangeOptions(_fbb, _o, _rehasher);
15862	}
15863
15864	inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15865	(void)_rehasher;
15866	(void)_o;
15867	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RangeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15868	return tflite::CreateRangeOptions(
15869	_fbb);
15870	}
15871
15872	inline LeakyReluOptionsT LeakyReluOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15873	auto _o = std::unique_ptr<LeakyReluOptionsT>(new LeakyReluOptionsT ());
15874	UnPackTo(_o.get(), _resolver);
15875	return _o.release();
15876	}
15877
15878	inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15879	(void)_o;
15880	(void)_resolver;
15881	{ auto _e = alpha(); _o->alpha = _e; }
15882	}
15883
15884	inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15885	return CreateLeakyReluOptions(_fbb, _o, _rehasher);
15886	}
15887
15888	inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15889	(void)_rehasher;
15890	(void)_o;
15891	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15892	auto _alpha = _o->alpha;
15893	return tflite::CreateLeakyReluOptions(
15894	_fbb,
15895	_alpha);
15896	}
15897
15898	inline SquaredDifferenceOptionsT SquaredDifferenceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15899	auto _o = std::unique_ptr<SquaredDifferenceOptionsT>(new SquaredDifferenceOptionsT ());
15900	UnPackTo(_o.get(), _resolver);
15901	return _o.release();
15902	}
15903
15904	inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15905	(void)_o;
15906	(void)_resolver;
15907	}
15908
15909	inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15910	return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
15911	}
15912
15913	inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15914	(void)_rehasher;
15915	(void)_o;
15916	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15917	return tflite::CreateSquaredDifferenceOptions(
15918	_fbb);
15919	}
15920
15921	inline MirrorPadOptionsT MirrorPadOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15922	auto _o = std::unique_ptr<MirrorPadOptionsT>(new MirrorPadOptionsT ());
15923	UnPackTo(_o.get(), _resolver);
15924	return _o.release();
15925	}
15926
15927	inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15928	(void)_o;
15929	(void)_resolver;
15930	{ auto _e = mode(); _o->mode = _e; }
15931	}
15932
15933	inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15934	return CreateMirrorPadOptions(_fbb, _o, _rehasher);
15935	}
15936
15937	inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15938	(void)_rehasher;
15939	(void)_o;
15940	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15941	auto _mode = _o->mode;
15942	return tflite::CreateMirrorPadOptions(
15943	_fbb,
15944	_mode);
15945	}
15946
15947	inline UniqueOptionsT UniqueOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15948	auto _o = std::unique_ptr<UniqueOptionsT>(new UniqueOptionsT ());
15949	UnPackTo(_o.get(), _resolver);
15950	return _o.release();
15951	}
15952
15953	inline void UniqueOptions::UnPackTo(UniqueOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15954	(void)_o;
15955	(void)_resolver;
15956	{ auto _e = idx_out_type(); _o->idx_out_type = _e; }
15957	}
15958
15959	inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15960	return CreateUniqueOptions(_fbb, _o, _rehasher);
15961	}
15962
15963	inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15964	(void)_rehasher;
15965	(void)_o;
15966	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UniqueOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15967	auto _idx_out_type = _o->idx_out_type;
15968	return tflite::CreateUniqueOptions(
15969	_fbb,
15970	_idx_out_type);
15971	}
15972
15973	inline ReverseV2OptionsT ReverseV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15974	auto _o = std::unique_ptr<ReverseV2OptionsT>(new ReverseV2OptionsT ());
15975	UnPackTo(_o.get(), _resolver);
15976	return _o.release();
15977	}
15978
15979	inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
15980	(void)_o;
15981	(void)_resolver;
15982	}
15983
15984	inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15985	return CreateReverseV2Options(_fbb, _o, _rehasher);
15986	}
15987
15988	inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
15989	(void)_rehasher;
15990	(void)_o;
15991	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
15992	return tflite::CreateReverseV2Options(
15993	_fbb);
15994	}
15995
15996	inline AddNOptionsT AddNOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
15997	auto _o = std::unique_ptr<AddNOptionsT>(new AddNOptionsT ());
15998	UnPackTo(_o.get(), _resolver);
15999	return _o.release();
16000	}
16001
16002	inline void AddNOptions::UnPackTo(AddNOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16003	(void)_o;
16004	(void)_resolver;
16005	}
16006
16007	inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16008	return CreateAddNOptions(_fbb, _o, _rehasher);
16009	}
16010
16011	inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16012	(void)_rehasher;
16013	(void)_o;
16014	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AddNOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16015	return tflite::CreateAddNOptions(
16016	_fbb);
16017	}
16018
16019	inline GatherNdOptionsT GatherNdOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16020	auto _o = std::unique_ptr<GatherNdOptionsT>(new GatherNdOptionsT ());
16021	UnPackTo(_o.get(), _resolver);
16022	return _o.release();
16023	}
16024
16025	inline void GatherNdOptions::UnPackTo(GatherNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16026	(void)_o;
16027	(void)_resolver;
16028	}
16029
16030	inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16031	return CreateGatherNdOptions(_fbb, _o, _rehasher);
16032	}
16033
16034	inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16035	(void)_rehasher;
16036	(void)_o;
16037	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16038	return tflite::CreateGatherNdOptions(
16039	_fbb);
16040	}
16041
16042	inline WhereOptionsT WhereOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16043	auto _o = std::unique_ptr<WhereOptionsT>(new WhereOptionsT ());
16044	UnPackTo(_o.get(), _resolver);
16045	return _o.release();
16046	}
16047
16048	inline void WhereOptions::UnPackTo(WhereOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16049	(void)_o;
16050	(void)_resolver;
16051	}
16052
16053	inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16054	return CreateWhereOptions(_fbb, _o, _rehasher);
16055	}
16056
16057	inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16058	(void)_rehasher;
16059	(void)_o;
16060	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* WhereOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16061	return tflite::CreateWhereOptions(
16062	_fbb);
16063	}
16064
16065	inline ReverseSequenceOptionsT ReverseSequenceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16066	auto _o = std::unique_ptr<ReverseSequenceOptionsT>(new ReverseSequenceOptionsT ());
16067	UnPackTo(_o.get(), _resolver);
16068	return _o.release();
16069	}
16070
16071	inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16072	(void)_o;
16073	(void)_resolver;
16074	{ auto _e = seq_dim(); _o->seq_dim = _e; }
16075	{ auto _e = batch_dim(); _o->batch_dim = _e; }
16076	}
16077
16078	inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16079	return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
16080	}
16081
16082	inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16083	(void)_rehasher;
16084	(void)_o;
16085	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16086	auto _seq_dim = _o->seq_dim;
16087	auto _batch_dim = _o->batch_dim;
16088	return tflite::CreateReverseSequenceOptions(
16089	_fbb,
16090	_seq_dim,
16091	_batch_dim);
16092	}
16093
16094	inline MatrixDiagOptionsT MatrixDiagOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16095	auto _o = std::unique_ptr<MatrixDiagOptionsT>(new MatrixDiagOptionsT ());
16096	UnPackTo(_o.get(), _resolver);
16097	return _o.release();
16098	}
16099
16100	inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16101	(void)_o;
16102	(void)_resolver;
16103	}
16104
16105	inline flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16106	return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
16107	}
16108
16109	inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16110	(void)_rehasher;
16111	(void)_o;
16112	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16113	return tflite::CreateMatrixDiagOptions(
16114	_fbb);
16115	}
16116
16117	inline QuantizeOptionsT QuantizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16118	auto _o = std::unique_ptr<QuantizeOptionsT>(new QuantizeOptionsT ());
16119	UnPackTo(_o.get(), _resolver);
16120	return _o.release();
16121	}
16122
16123	inline void QuantizeOptions::UnPackTo(QuantizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16124	(void)_o;
16125	(void)_resolver;
16126	}
16127
16128	inline flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16129	return CreateQuantizeOptions(_fbb, _o, _rehasher);
16130	}
16131
16132	inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16133	(void)_rehasher;
16134	(void)_o;
16135	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16136	return tflite::CreateQuantizeOptions(
16137	_fbb);
16138	}
16139
16140	inline MatrixSetDiagOptionsT MatrixSetDiagOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16141	auto _o = std::unique_ptr<MatrixSetDiagOptionsT>(new MatrixSetDiagOptionsT ());
16142	UnPackTo(_o.get(), _resolver);
16143	return _o.release();
16144	}
16145
16146	inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16147	(void)_o;
16148	(void)_resolver;
16149	}
16150
16151	inline flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16152	return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
16153	}
16154
16155	inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16156	(void)_rehasher;
16157	(void)_o;
16158	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16159	return tflite::CreateMatrixSetDiagOptions(
16160	_fbb);
16161	}
16162
16163	inline IfOptionsT IfOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16164	auto _o = std::unique_ptr<IfOptionsT>(new IfOptionsT ());
16165	UnPackTo(_o.get(), _resolver);
16166	return _o.release();
16167	}
16168
16169	inline void IfOptions::UnPackTo(IfOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16170	(void)_o;
16171	(void)_resolver;
16172	{ auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; }
16173	{ auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; }
16174	}
16175
16176	inline flatbuffers::Offset<IfOptions> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16177	return CreateIfOptions(_fbb, _o, _rehasher);
16178	}
16179
16180	inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16181	(void)_rehasher;
16182	(void)_o;
16183	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* IfOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16184	auto _then_subgraph_index = _o->then_subgraph_index;
16185	auto _else_subgraph_index = _o->else_subgraph_index;
16186	return tflite::CreateIfOptions(
16187	_fbb,
16188	_then_subgraph_index,
16189	_else_subgraph_index);
16190	}
16191
16192	inline CallOnceOptionsT CallOnceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16193	auto _o = std::unique_ptr<CallOnceOptionsT>(new CallOnceOptionsT ());
16194	UnPackTo(_o.get(), _resolver);
16195	return _o.release();
16196	}
16197
16198	inline void CallOnceOptions::UnPackTo(CallOnceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16199	(void)_o;
16200	(void)_resolver;
16201	{ auto _e = init_subgraph_index(); _o->init_subgraph_index = _e; }
16202	}
16203
16204	inline flatbuffers::Offset<CallOnceOptions> CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16205	return CreateCallOnceOptions(_fbb, _o, _rehasher);
16206	}
16207
16208	inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16209	(void)_rehasher;
16210	(void)_o;
16211	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CallOnceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16212	auto _init_subgraph_index = _o->init_subgraph_index;
16213	return tflite::CreateCallOnceOptions(
16214	_fbb,
16215	_init_subgraph_index);
16216	}
16217
16218	inline WhileOptionsT WhileOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16219	auto _o = std::unique_ptr<WhileOptionsT>(new WhileOptionsT ());
16220	UnPackTo(_o.get(), _resolver);
16221	return _o.release();
16222	}
16223
16224	inline void WhileOptions::UnPackTo(WhileOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16225	(void)_o;
16226	(void)_resolver;
16227	{ auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; }
16228	{ auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; }
16229	}
16230
16231	inline flatbuffers::Offset<WhileOptions> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16232	return CreateWhileOptions(_fbb, _o, _rehasher);
16233	}
16234
16235	inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16236	(void)_rehasher;
16237	(void)_o;
16238	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* WhileOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16239	auto _cond_subgraph_index = _o->cond_subgraph_index;
16240	auto _body_subgraph_index = _o->body_subgraph_index;
16241	return tflite::CreateWhileOptions(
16242	_fbb,
16243	_cond_subgraph_index,
16244	_body_subgraph_index);
16245	}
16246
16247	inline NonMaxSuppressionV4OptionsT NonMaxSuppressionV4Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16248	auto _o = std::unique_ptr<NonMaxSuppressionV4OptionsT>(new NonMaxSuppressionV4OptionsT ());
16249	UnPackTo(_o.get(), _resolver);
16250	return _o.release();
16251	}
16252
16253	inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16254	(void)_o;
16255	(void)_resolver;
16256	}
16257
16258	inline flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16259	return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
16260	}
16261
16262	inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16263	(void)_rehasher;
16264	(void)_o;
16265	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16266	return tflite::CreateNonMaxSuppressionV4Options(
16267	_fbb);
16268	}
16269
16270	inline NonMaxSuppressionV5OptionsT NonMaxSuppressionV5Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16271	auto _o = std::unique_ptr<NonMaxSuppressionV5OptionsT>(new NonMaxSuppressionV5OptionsT ());
16272	UnPackTo(_o.get(), _resolver);
16273	return _o.release();
16274	}
16275
16276	inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16277	(void)_o;
16278	(void)_resolver;
16279	}
16280
16281	inline flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16282	return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
16283	}
16284
16285	inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16286	(void)_rehasher;
16287	(void)_o;
16288	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16289	return tflite::CreateNonMaxSuppressionV5Options(
16290	_fbb);
16291	}
16292
16293	inline ScatterNdOptionsT ScatterNdOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16294	auto _o = std::unique_ptr<ScatterNdOptionsT>(new ScatterNdOptionsT ());
16295	UnPackTo(_o.get(), _resolver);
16296	return _o.release();
16297	}
16298
16299	inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16300	(void)_o;
16301	(void)_resolver;
16302	}
16303
16304	inline flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16305	return CreateScatterNdOptions(_fbb, _o, _rehasher);
16306	}
16307
16308	inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16309	(void)_rehasher;
16310	(void)_o;
16311	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16312	return tflite::CreateScatterNdOptions(
16313	_fbb);
16314	}
16315
16316	inline SelectV2OptionsT SelectV2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16317	auto _o = std::unique_ptr<SelectV2OptionsT>(new SelectV2OptionsT ());
16318	UnPackTo(_o.get(), _resolver);
16319	return _o.release();
16320	}
16321
16322	inline void SelectV2Options::UnPackTo(SelectV2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16323	(void)_o;
16324	(void)_resolver;
16325	}
16326
16327	inline flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16328	return CreateSelectV2Options(_fbb, _o, _rehasher);
16329	}
16330
16331	inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16332	(void)_rehasher;
16333	(void)_o;
16334	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16335	return tflite::CreateSelectV2Options(
16336	_fbb);
16337	}
16338
16339	inline DensifyOptionsT DensifyOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16340	auto _o = std::unique_ptr<DensifyOptionsT>(new DensifyOptionsT ());
16341	UnPackTo(_o.get(), _resolver);
16342	return _o.release();
16343	}
16344
16345	inline void DensifyOptions::UnPackTo(DensifyOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16346	(void)_o;
16347	(void)_resolver;
16348	}
16349
16350	inline flatbuffers::Offset<DensifyOptions> DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16351	return CreateDensifyOptions(_fbb, _o, _rehasher);
16352	}
16353
16354	inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16355	(void)_rehasher;
16356	(void)_o;
16357	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DensifyOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16358	return tflite::CreateDensifyOptions(
16359	_fbb);
16360	}
16361
16362	inline SegmentSumOptionsT SegmentSumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16363	auto _o = std::unique_ptr<SegmentSumOptionsT>(new SegmentSumOptionsT ());
16364	UnPackTo(_o.get(), _resolver);
16365	return _o.release();
16366	}
16367
16368	inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16369	(void)_o;
16370	(void)_resolver;
16371	}
16372
16373	inline flatbuffers::Offset<SegmentSumOptions> SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16374	return CreateSegmentSumOptions(_fbb, _o, _rehasher);
16375	}
16376
16377	inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16378	(void)_rehasher;
16379	(void)_o;
16380	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16381	return tflite::CreateSegmentSumOptions(
16382	_fbb);
16383	}
16384
16385	inline BatchMatMulOptionsT BatchMatMulOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16386	auto _o = std::unique_ptr<BatchMatMulOptionsT>(new BatchMatMulOptionsT ());
16387	UnPackTo(_o.get(), _resolver);
16388	return _o.release();
16389	}
16390
16391	inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16392	(void)_o;
16393	(void)_resolver;
16394	{ auto _e = adj_x(); _o->adj_x = _e; }
16395	{ auto _e = adj_y(); _o->adj_y = _e; }
16396	{ auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
16397	}
16398
16399	inline flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16400	return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
16401	}
16402
16403	inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16404	(void)_rehasher;
16405	(void)_o;
16406	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BatchMatMulOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16407	auto _adj_x = _o->adj_x;
16408	auto _adj_y = _o->adj_y;
16409	auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16410	return tflite::CreateBatchMatMulOptions(
16411	_fbb,
16412	_adj_x,
16413	_adj_y,
16414	_asymmetric_quantize_inputs);
16415	}
16416
16417	inline CumsumOptionsT CumsumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16418	auto _o = std::unique_ptr<CumsumOptionsT>(new CumsumOptionsT ());
16419	UnPackTo(_o.get(), _resolver);
16420	return _o.release();
16421	}
16422
16423	inline void CumsumOptions::UnPackTo(CumsumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16424	(void)_o;
16425	(void)_resolver;
16426	{ auto _e = exclusive(); _o->exclusive = _e; }
16427	{ auto _e = reverse(); _o->reverse = _e; }
16428	}
16429
16430	inline flatbuffers::Offset<CumsumOptions> CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16431	return CreateCumsumOptions(_fbb, _o, _rehasher);
16432	}
16433
16434	inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16435	(void)_rehasher;
16436	(void)_o;
16437	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* CumsumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16438	auto _exclusive = _o->exclusive;
16439	auto _reverse = _o->reverse;
16440	return tflite::CreateCumsumOptions(
16441	_fbb,
16442	_exclusive,
16443	_reverse);
16444	}
16445
16446	inline BroadcastToOptionsT BroadcastToOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16447	auto _o = std::unique_ptr<BroadcastToOptionsT>(new BroadcastToOptionsT ());
16448	UnPackTo(_o.get(), _resolver);
16449	return _o.release();
16450	}
16451
16452	inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16453	(void)_o;
16454	(void)_resolver;
16455	}
16456
16457	inline flatbuffers::Offset<BroadcastToOptions> BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16458	return CreateBroadcastToOptions(_fbb, _o, _rehasher);
16459	}
16460
16461	inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16462	(void)_rehasher;
16463	(void)_o;
16464	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BroadcastToOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16465	return tflite::CreateBroadcastToOptions(
16466	_fbb);
16467	}
16468
16469	inline Rfft2dOptionsT Rfft2dOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16470	auto _o = std::unique_ptr<Rfft2dOptionsT>(new Rfft2dOptionsT ());
16471	UnPackTo(_o.get(), _resolver);
16472	return _o.release();
16473	}
16474
16475	inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16476	(void)_o;
16477	(void)_resolver;
16478	}
16479
16480	inline flatbuffers::Offset<Rfft2dOptions> Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16481	return CreateRfft2dOptions(_fbb, _o, _rehasher);
16482	}
16483
16484	inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16485	(void)_rehasher;
16486	(void)_o;
16487	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* Rfft2dOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16488	return tflite::CreateRfft2dOptions(
16489	_fbb);
16490	}
16491
16492	inline HashtableOptionsT HashtableOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16493	auto _o = std::unique_ptr<HashtableOptionsT>(new HashtableOptionsT ());
16494	UnPackTo(_o.get(), _resolver);
16495	return _o.release();
16496	}
16497
16498	inline void HashtableOptions::UnPackTo(HashtableOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16499	(void)_o;
16500	(void)_resolver;
16501	{ auto _e = table_id(); _o->table_id = _e; }
16502	{ auto _e = key_dtype(); _o->key_dtype = _e; }
16503	{ auto _e = value_dtype(); _o->value_dtype = _e; }
16504	}
16505
16506	inline flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16507	return CreateHashtableOptions(_fbb, _o, _rehasher);
16508	}
16509
16510	inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16511	(void)_rehasher;
16512	(void)_o;
16513	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16514	auto _table_id = _o->table_id;
16515	auto _key_dtype = _o->key_dtype;
16516	auto _value_dtype = _o->value_dtype;
16517	return tflite::CreateHashtableOptions(
16518	_fbb,
16519	_table_id,
16520	_key_dtype,
16521	_value_dtype);
16522	}
16523
16524	inline HashtableFindOptionsT HashtableFindOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16525	auto _o = std::unique_ptr<HashtableFindOptionsT>(new HashtableFindOptionsT ());
16526	UnPackTo(_o.get(), _resolver);
16527	return _o.release();
16528	}
16529
16530	inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16531	(void)_o;
16532	(void)_resolver;
16533	}
16534
16535	inline flatbuffers::Offset<HashtableFindOptions> HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16536	return CreateHashtableFindOptions(_fbb, _o, _rehasher);
16537	}
16538
16539	inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16540	(void)_rehasher;
16541	(void)_o;
16542	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableFindOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16543	return tflite::CreateHashtableFindOptions(
16544	_fbb);
16545	}
16546
16547	inline HashtableImportOptionsT HashtableImportOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16548	auto _o = std::unique_ptr<HashtableImportOptionsT>(new HashtableImportOptionsT ());
16549	UnPackTo(_o.get(), _resolver);
16550	return _o.release();
16551	}
16552
16553	inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16554	(void)_o;
16555	(void)_resolver;
16556	}
16557
16558	inline flatbuffers::Offset<HashtableImportOptions> HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16559	return CreateHashtableImportOptions(_fbb, _o, _rehasher);
16560	}
16561
16562	inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16563	(void)_rehasher;
16564	(void)_o;
16565	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableImportOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16566	return tflite::CreateHashtableImportOptions(
16567	_fbb);
16568	}
16569
16570	inline HashtableSizeOptionsT HashtableSizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16571	auto _o = std::unique_ptr<HashtableSizeOptionsT>(new HashtableSizeOptionsT ());
16572	UnPackTo(_o.get(), _resolver);
16573	return _o.release();
16574	}
16575
16576	inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16577	(void)_o;
16578	(void)_resolver;
16579	}
16580
16581	inline flatbuffers::Offset<HashtableSizeOptions> HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16582	return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
16583	}
16584
16585	inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16586	(void)_rehasher;
16587	(void)_o;
16588	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* HashtableSizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16589	return tflite::CreateHashtableSizeOptions(
16590	_fbb);
16591	}
16592
16593	inline VarHandleOptionsT VarHandleOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16594	auto _o = std::unique_ptr<VarHandleOptionsT>(new VarHandleOptionsT ());
16595	UnPackTo(_o.get(), _resolver);
16596	return _o.release();
16597	}
16598
16599	inline void VarHandleOptions::UnPackTo(VarHandleOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16600	(void)_o;
16601	(void)_resolver;
16602	{ auto _e = container(); if (_e) _o->container = _e->str(); }
16603	{ auto _e = shared_name(); if (_e) _o->shared_name = _e->str(); }
16604	}
16605
16606	inline flatbuffers::Offset<VarHandleOptions> VarHandleOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16607	return CreateVarHandleOptions(_fbb, _o, _rehasher);
16608	}
16609
16610	inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16611	(void)_rehasher;
16612	(void)_o;
16613	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* VarHandleOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16614	auto _container = _o->container.empty() ? `0` : _fbb.CreateString(_o->container);
16615	auto _shared_name = _o->shared_name.empty() ? `0` : _fbb.CreateString(_o->shared_name);
16616	return tflite::CreateVarHandleOptions(
16617	_fbb,
16618	_container,
16619	_shared_name);
16620	}
16621
16622	inline ReadVariableOptionsT ReadVariableOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16623	auto _o = std::unique_ptr<ReadVariableOptionsT>(new ReadVariableOptionsT ());
16624	UnPackTo(_o.get(), _resolver);
16625	return _o.release();
16626	}
16627
16628	inline void ReadVariableOptions::UnPackTo(ReadVariableOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16629	(void)_o;
16630	(void)_resolver;
16631	}
16632
16633	inline flatbuffers::Offset<ReadVariableOptions> ReadVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16634	return CreateReadVariableOptions(_fbb, _o, _rehasher);
16635	}
16636
16637	inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16638	(void)_rehasher;
16639	(void)_o;
16640	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ReadVariableOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16641	return tflite::CreateReadVariableOptions(
16642	_fbb);
16643	}
16644
16645	inline AssignVariableOptionsT AssignVariableOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16646	auto _o = std::unique_ptr<AssignVariableOptionsT>(new AssignVariableOptionsT ());
16647	UnPackTo(_o.get(), _resolver);
16648	return _o.release();
16649	}
16650
16651	inline void AssignVariableOptions::UnPackTo(AssignVariableOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16652	(void)_o;
16653	(void)_resolver;
16654	}
16655
16656	inline flatbuffers::Offset<AssignVariableOptions> AssignVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16657	return CreateAssignVariableOptions(_fbb, _o, _rehasher);
16658	}
16659
16660	inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16661	(void)_rehasher;
16662	(void)_o;
16663	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* AssignVariableOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16664	return tflite::CreateAssignVariableOptions(
16665	_fbb);
16666	}
16667
16668	inline RandomOptionsT RandomOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16669	auto _o = std::unique_ptr<RandomOptionsT>(new RandomOptionsT ());
16670	UnPackTo(_o.get(), _resolver);
16671	return _o.release();
16672	}
16673
16674	inline void RandomOptions::UnPackTo(RandomOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16675	(void)_o;
16676	(void)_resolver;
16677	{ auto _e = seed(); _o->seed = _e; }
16678	{ auto _e = seed2(); _o->seed2 = _e; }
16679	}
16680
16681	inline flatbuffers::Offset<RandomOptions> RandomOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16682	return CreateRandomOptions(_fbb, _o, _rehasher);
16683	}
16684
16685	inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16686	(void)_rehasher;
16687	(void)_o;
16688	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* RandomOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16689	auto _seed = _o->seed;
16690	auto _seed2 = _o->seed2;
16691	return tflite::CreateRandomOptions(
16692	_fbb,
16693	_seed,
16694	_seed2);
16695	}
16696
16697	inline BucketizeOptionsT BucketizeOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16698	auto _o = std::unique_ptr<BucketizeOptionsT>(new BucketizeOptionsT ());
16699	UnPackTo(_o.get(), _resolver);
16700	return _o.release();
16701	}
16702
16703	inline void BucketizeOptions::UnPackTo(BucketizeOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16704	(void)_o;
16705	(void)_resolver;
16706	{ auto _e = boundaries(); if (_e) { _o->boundaries.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->boundaries [_i] = _e->Get(_i); } } }
16707	}
16708
16709	inline flatbuffers::Offset<BucketizeOptions> BucketizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16710	return CreateBucketizeOptions(_fbb, _o, _rehasher);
16711	}
16712
16713	inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16714	(void)_rehasher;
16715	(void)_o;
16716	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BucketizeOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16717	auto _boundaries = _o->boundaries.size() ? _fbb.CreateVector(_o->boundaries) : `0`;
16718	return tflite::CreateBucketizeOptions(
16719	_fbb,
16720	_boundaries);
16721	}
16722
16723	inline GeluOptionsT GeluOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16724	auto _o = std::unique_ptr<GeluOptionsT>(new GeluOptionsT ());
16725	UnPackTo(_o.get(), _resolver);
16726	return _o.release();
16727	}
16728
16729	inline void GeluOptions::UnPackTo(GeluOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16730	(void)_o;
16731	(void)_resolver;
16732	{ auto _e = approximate(); _o->approximate = _e; }
16733	}
16734
16735	inline flatbuffers::Offset<GeluOptions> GeluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16736	return CreateGeluOptions(_fbb, _o, _rehasher);
16737	}
16738
16739	inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16740	(void)_rehasher;
16741	(void)_o;
16742	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* GeluOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16743	auto _approximate = _o->approximate;
16744	return tflite::CreateGeluOptions(
16745	_fbb,
16746	_approximate);
16747	}
16748
16749	inline DynamicUpdateSliceOptionsT DynamicUpdateSliceOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16750	auto _o = std::unique_ptr<DynamicUpdateSliceOptionsT>(new DynamicUpdateSliceOptionsT ());
16751	UnPackTo(_o.get(), _resolver);
16752	return _o.release();
16753	}
16754
16755	inline void DynamicUpdateSliceOptions::UnPackTo(DynamicUpdateSliceOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16756	(void)_o;
16757	(void)_resolver;
16758	}
16759
16760	inline flatbuffers::Offset<DynamicUpdateSliceOptions> DynamicUpdateSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16761	return CreateDynamicUpdateSliceOptions(_fbb, _o, _rehasher);
16762	}
16763
16764	inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16765	(void)_rehasher;
16766	(void)_o;
16767	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* DynamicUpdateSliceOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16768	return tflite::CreateDynamicUpdateSliceOptions(
16769	_fbb);
16770	}
16771
16772	inline UnsortedSegmentProdOptionsT UnsortedSegmentProdOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16773	auto _o = std::unique_ptr<UnsortedSegmentProdOptionsT>(new UnsortedSegmentProdOptionsT ());
16774	UnPackTo(_o.get(), _resolver);
16775	return _o.release();
16776	}
16777
16778	inline void UnsortedSegmentProdOptions::UnPackTo(UnsortedSegmentProdOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16779	(void)_o;
16780	(void)_resolver;
16781	}
16782
16783	inline flatbuffers::Offset<UnsortedSegmentProdOptions> UnsortedSegmentProdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16784	return CreateUnsortedSegmentProdOptions(_fbb, _o, _rehasher);
16785	}
16786
16787	inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16788	(void)_rehasher;
16789	(void)_o;
16790	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnsortedSegmentProdOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16791	return tflite::CreateUnsortedSegmentProdOptions(
16792	_fbb);
16793	}
16794
16795	inline UnsortedSegmentMaxOptionsT UnsortedSegmentMaxOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16796	auto _o = std::unique_ptr<UnsortedSegmentMaxOptionsT>(new UnsortedSegmentMaxOptionsT ());
16797	UnPackTo(_o.get(), _resolver);
16798	return _o.release();
16799	}
16800
16801	inline void UnsortedSegmentMaxOptions::UnPackTo(UnsortedSegmentMaxOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16802	(void)_o;
16803	(void)_resolver;
16804	}
16805
16806	inline flatbuffers::Offset<UnsortedSegmentMaxOptions> UnsortedSegmentMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16807	return CreateUnsortedSegmentMaxOptions(_fbb, _o, _rehasher);
16808	}
16809
16810	inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16811	(void)_rehasher;
16812	(void)_o;
16813	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnsortedSegmentMaxOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16814	return tflite::CreateUnsortedSegmentMaxOptions(
16815	_fbb);
16816	}
16817
16818	inline UnsortedSegmentSumOptionsT UnsortedSegmentSumOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16819	auto _o = std::unique_ptr<UnsortedSegmentSumOptionsT>(new UnsortedSegmentSumOptionsT ());
16820	UnPackTo(_o.get(), _resolver);
16821	return _o.release();
16822	}
16823
16824	inline void UnsortedSegmentSumOptions::UnPackTo(UnsortedSegmentSumOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16825	(void)_o;
16826	(void)_resolver;
16827	}
16828
16829	inline flatbuffers::Offset<UnsortedSegmentSumOptions> UnsortedSegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16830	return CreateUnsortedSegmentSumOptions(_fbb, _o, _rehasher);
16831	}
16832
16833	inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16834	(void)_rehasher;
16835	(void)_o;
16836	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnsortedSegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16837	return tflite::CreateUnsortedSegmentSumOptions(
16838	_fbb);
16839	}
16840
16841	inline ATan2OptionsT ATan2Options::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16842	auto _o = std::unique_ptr<ATan2OptionsT>(new ATan2OptionsT ());
16843	UnPackTo(_o.get(), _resolver);
16844	return _o.release();
16845	}
16846
16847	inline void ATan2Options::UnPackTo(ATan2OptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16848	(void)_o;
16849	(void)_resolver;
16850	}
16851
16852	inline flatbuffers::Offset<ATan2Options> ATan2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16853	return CreateATan2Options(_fbb, _o, _rehasher);
16854	}
16855
16856	inline flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16857	(void)_rehasher;
16858	(void)_o;
16859	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ATan2OptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16860	return tflite::CreateATan2Options(
16861	_fbb);
16862	}
16863
16864	inline UnsortedSegmentMinOptionsT UnsortedSegmentMinOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16865	auto _o = std::unique_ptr<UnsortedSegmentMinOptionsT>(new UnsortedSegmentMinOptionsT ());
16866	UnPackTo(_o.get(), _resolver);
16867	return _o.release();
16868	}
16869
16870	inline void UnsortedSegmentMinOptions::UnPackTo(UnsortedSegmentMinOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16871	(void)_o;
16872	(void)_resolver;
16873	}
16874
16875	inline flatbuffers::Offset<UnsortedSegmentMinOptions> UnsortedSegmentMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16876	return CreateUnsortedSegmentMinOptions(_fbb, _o, _rehasher);
16877	}
16878
16879	inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16880	(void)_rehasher;
16881	(void)_o;
16882	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* UnsortedSegmentMinOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16883	return tflite::CreateUnsortedSegmentMinOptions(
16884	_fbb);
16885	}
16886
16887	inline SignOptionsT SignOptions::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16888	auto _o = std::unique_ptr<SignOptionsT>(new SignOptionsT ());
16889	UnPackTo(_o.get(), _resolver);
16890	return _o.release();
16891	}
16892
16893	inline void SignOptions::UnPackTo(SignOptionsT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16894	(void)_o;
16895	(void)_resolver;
16896	}
16897
16898	inline flatbuffers::Offset<SignOptions> SignOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16899	return CreateSignOptions(_fbb, _o, _rehasher);
16900	}
16901
16902	inline flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16903	(void)_rehasher;
16904	(void)_o;
16905	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SignOptionsT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16906	return tflite::CreateSignOptions(
16907	_fbb);
16908	}
16909
16910	inline OperatorCodeT OperatorCode::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16911	auto _o = std::unique_ptr<OperatorCodeT>(new OperatorCodeT ());
16912	UnPackTo(_o.get(), _resolver);
16913	return _o.release();
16914	}
16915
16916	inline void OperatorCode::UnPackTo(OperatorCodeT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16917	(void)_o;
16918	(void)_resolver;
16919	{ auto _e = deprecated_builtin_code(); _o->deprecated_builtin_code = _e; }
16920	{ auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }
16921	{ auto _e = version(); _o->version = _e; }
16922	{ auto _e = builtin_code(); _o->builtin_code = _e; }
16923	}
16924
16925	inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16926	return CreateOperatorCode(_fbb, _o, _rehasher);
16927	}
16928
16929	inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16930	(void)_rehasher;
16931	(void)_o;
16932	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OperatorCodeT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16933	auto _deprecated_builtin_code = _o->deprecated_builtin_code;
16934	auto _custom_code = _o->custom_code.empty() ? `0` : _fbb.CreateString(_o->custom_code);
16935	auto _version = _o->version;
16936	auto _builtin_code = _o->builtin_code;
16937	return tflite::CreateOperatorCode(
16938	_fbb,
16939	_deprecated_builtin_code,
16940	_custom_code,
16941	_version,
16942	_builtin_code);
16943	}
16944
16945	inline OperatorT Operator::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
16946	auto _o = std::unique_ptr<OperatorT>(new OperatorT ());
16947	UnPackTo(_o.get(), _resolver);
16948	return _o.release();
16949	}
16950
16951	inline void Operator::UnPackTo(OperatorT _o, const* flatbuffers::resolver_function_t _resolver) const* {
16952	(void)_o;
16953	(void)_resolver;
16954	{ auto _e = opcode_index(); _o->opcode_index = _e; }
16955	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->inputs [_i] = _e->Get(_i); } } }
16956	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->outputs [_i] = _e->Get(_i); } } }
16957	{ auto _e = builtin_options_type(); _o->builtin_options.type = _e; }
16958	{ auto _e = builtin_options(); if (_e) _o->builtin_options.value = tflite::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }
16959	{ auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_options.begin()); } }
16960	{ auto _e = custom_options_format(); _o->custom_options_format = _e; }
16961	{ auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->mutating_variable_inputs [_i] = _e->Get(_i) != `0`; } } }
16962	{ auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->intermediates [_i] = _e->Get(_i); } } }
16963	}
16964
16965	inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16966	return CreateOperator(_fbb, _o, _rehasher);
16967	}
16968
16969	inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
16970	(void)_rehasher;
16971	(void)_o;
16972	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* OperatorT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
16973	auto _opcode_index = _o->opcode_index;
16974	auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : `0`;
16975	auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : `0`;
16976	auto _builtin_options_type = _o->builtin_options.type;
16977	auto _builtin_options = _o->builtin_options.Pack(_fbb);
16978	auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : `0`;
16979	auto _custom_options_format = _o->custom_options_format;
16980	auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : `0`;
16981	auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : `0`;
16982	return tflite::CreateOperator(
16983	_fbb,
16984	_opcode_index,
16985	_inputs,
16986	_outputs,
16987	_builtin_options_type,
16988	_builtin_options,
16989	_custom_options,
16990	_custom_options_format,
16991	_mutating_variable_inputs,
16992	_intermediates);
16993	}
16994
16995	inline SubGraphT::SubGraphT(const SubGraphT &o)
16996	: inputs (o.inputs),
16997	outputs (o.outputs),
16998	name (o.name) {
16999	tensors.reserve(o.tensors.size());
17000	for (const auto &v : o.tensors) { tensors.emplace_back((v) ? new tflite::TensorT (v) : nullptr*); }
17001	operators.reserve(o.operators.size());
17002	for (const auto &v : o.operators) { operators.emplace_back((v) ? new tflite::OperatorT (v) : nullptr*); }
17003	}
17004
17005	inline SubGraphT &SubGraphT::operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT {
17006	std::swap(tensors, o.tensors);
17007	std::swap(inputs, o.inputs);
17008	std::swap(outputs, o.outputs);
17009	std::swap(operators, o.operators);
17010	std::swap(name, o.name);
17011	return *this;
17012	}
17013
17014	inline SubGraphT SubGraph::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17015	auto _o = std::unique_ptr<SubGraphT>(new SubGraphT ());
17016	UnPackTo(_o.get(), _resolver);
17017	return _o.release();
17018	}
17019
17020	inline void SubGraph::UnPackTo(SubGraphT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17021	(void)_o;
17022	(void)_resolver;
17023	{ auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->tensors [_i]) { _e->Get(_i)->UnPackTo(_o->tensors [_i].get(), _resolver); } else { _o->tensors [_i] = std::unique_ptr<tflite::TensorT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17024	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->inputs [_i] = _e->Get(_i); } } }
17025	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->outputs [_i] = _e->Get(_i); } } }
17026	{ auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->operators [_i]) { _e->Get(_i)->UnPackTo(_o->operators [_i].get(), _resolver); } else { _o->operators [_i] = std::unique_ptr<tflite::OperatorT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17027	{ auto _e = name(); if (_e) _o->name = _e->str(); }
17028	}
17029
17030	inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17031	return CreateSubGraph(_fbb, _o, _rehasher);
17032	}
17033
17034	inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17035	(void)_rehasher;
17036	(void)_o;
17037	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SubGraphT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17038	auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs __va) { return* CreateTensor(*__va->__fbb, __va->__o->tensors [i].get(), __va->__rehasher); }, &_va ) : `0`;
17039	auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : `0`;
17040	auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : `0`;
17041	auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>> (_o->operators.size(), [](size_t i, _VectorArgs __va) { return* CreateOperator(*__va->__fbb, __va->__o->operators [i].get(), __va->__rehasher); }, &_va ) : `0`;
17042	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
17043	return tflite::CreateSubGraph(
17044	_fbb,
17045	_tensors,
17046	_inputs,
17047	_outputs,
17048	_operators,
17049	_name);
17050	}
17051
17052	inline BufferT Buffer::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17053	auto _o = std::unique_ptr<BufferT>(new BufferT ());
17054	UnPackTo(_o.get(), _resolver);
17055	return _o.release();
17056	}
17057
17058	inline void Buffer::UnPackTo(BufferT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17059	(void)_o;
17060	(void)_resolver;
17061	{ auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
17062	}
17063
17064	inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17065	return CreateBuffer(_fbb, _o, _rehasher);
17066	}
17067
17068	inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17069	(void)_rehasher;
17070	(void)_o;
17071	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* BufferT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17072	_fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), `16`);
17073	auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : `0`;
17074	return tflite::CreateBuffer(
17075	_fbb,
17076	_data);
17077	}
17078
17079	inline MetadataT Metadata::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17080	auto _o = std::unique_ptr<MetadataT>(new MetadataT ());
17081	UnPackTo(_o.get(), _resolver);
17082	return _o.release();
17083	}
17084
17085	inline void Metadata::UnPackTo(MetadataT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17086	(void)_o;
17087	(void)_resolver;
17088	{ auto _e = name(); if (_e) _o->name = _e->str(); }
17089	{ auto _e = buffer(); _o->buffer = _e; }
17090	}
17091
17092	inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17093	return CreateMetadata(_fbb, _o, _rehasher);
17094	}
17095
17096	inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17097	(void)_rehasher;
17098	(void)_o;
17099	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* MetadataT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17100	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
17101	auto _buffer = _o->buffer;
17102	return tflite::CreateMetadata(
17103	_fbb,
17104	_name,
17105	_buffer);
17106	}
17107
17108	inline TensorMapT TensorMap::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17109	auto _o = std::unique_ptr<TensorMapT>(new TensorMapT ());
17110	UnPackTo(_o.get(), _resolver);
17111	return _o.release();
17112	}
17113
17114	inline void TensorMap::UnPackTo(TensorMapT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17115	(void)_o;
17116	(void)_resolver;
17117	{ auto _e = name(); if (_e) _o->name = _e->str(); }
17118	{ auto _e = tensor_index(); _o->tensor_index = _e; }
17119	}
17120
17121	inline flatbuffers::Offset<TensorMap> TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17122	return CreateTensorMap(_fbb, _o, _rehasher);
17123	}
17124
17125	inline flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17126	(void)_rehasher;
17127	(void)_o;
17128	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* TensorMapT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17129	auto _name = _o->name.empty() ? `0` : _fbb.CreateString(_o->name);
17130	auto _tensor_index = _o->tensor_index;
17131	return tflite::CreateTensorMap(
17132	_fbb,
17133	_name,
17134	_tensor_index);
17135	}
17136
17137	inline SignatureDefT::SignatureDefT(const SignatureDefT &o)
17138	: signature_key (o.signature_key),
17139	subgraph_index(o.subgraph_index) {
17140	inputs.reserve(o.inputs.size());
17141	for (const auto &v : o.inputs) { inputs.emplace_back((v) ? new tflite::TensorMapT (v) : nullptr*); }
17142	outputs.reserve(o.outputs.size());
17143	for (const auto &v : o.outputs) { outputs.emplace_back((v) ? new tflite::TensorMapT (v) : nullptr*); }
17144	}
17145
17146	inline SignatureDefT &SignatureDefT::operator=(SignatureDefT o) FLATBUFFERS_NOEXCEPT {
17147	std::swap(inputs, o.inputs);
17148	std::swap(outputs, o.outputs);
17149	std::swap(signature_key, o.signature_key);
17150	std::swap(subgraph_index, o.subgraph_index);
17151	return *this;
17152	}
17153
17154	inline SignatureDefT SignatureDef::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17155	auto _o = std::unique_ptr<SignatureDefT>(new SignatureDefT ());
17156	UnPackTo(_o.get(), _resolver);
17157	return _o.release();
17158	}
17159
17160	inline void SignatureDef::UnPackTo(SignatureDefT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17161	(void)_o;
17162	(void)_resolver;
17163	{ auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->inputs [_i]) { _e->Get(_i)->UnPackTo(_o->inputs [_i].get(), _resolver); } else { _o->inputs [_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17164	{ auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->outputs [_i]) { _e->Get(_i)->UnPackTo(_o->outputs [_i].get(), _resolver); } else { _o->outputs [_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17165	{ auto _e = signature_key(); if (_e) _o->signature_key = _e->str(); }
17166	{ auto _e = subgraph_index(); _o->subgraph_index = _e; }
17167	}
17168
17169	inline flatbuffers::Offset<SignatureDef> SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17170	return CreateSignatureDef(_fbb, _o, _rehasher);
17171	}
17172
17173	inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17174	(void)_rehasher;
17175	(void)_o;
17176	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* SignatureDefT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17177	auto _inputs = _o->inputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->inputs.size(), [](size_t i, _VectorArgs __va) { return* CreateTensorMap(*__va->__fbb, __va->__o->inputs [i].get(), __va->__rehasher); }, &_va ) : `0`;
17178	auto _outputs = _o->outputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->outputs.size(), [](size_t i, _VectorArgs __va) { return* CreateTensorMap(*__va->__fbb, __va->__o->outputs [i].get(), __va->__rehasher); }, &_va ) : `0`;
17179	auto _signature_key = _o->signature_key.empty() ? `0` : _fbb.CreateString(_o->signature_key);
17180	auto _subgraph_index = _o->subgraph_index;
17181	return tflite::CreateSignatureDef(
17182	_fbb,
17183	_inputs,
17184	_outputs,
17185	_signature_key,
17186	_subgraph_index);
17187	}
17188
17189	inline ModelT::ModelT(const ModelT &o)
17190	: version(o.version),
17191	description (o.description),
17192	metadata_buffer (o.metadata_buffer) {
17193	operator_codes.reserve(o.operator_codes.size());
17194	for (const auto &v : o.operator_codes) { operator_codes.emplace_back((v) ? new tflite::OperatorCodeT (v) : nullptr*); }
17195	subgraphs.reserve(o.subgraphs.size());
17196	for (const auto &v : o.subgraphs) { subgraphs.emplace_back((v) ? new tflite::SubGraphT (v) : nullptr*); }
17197	buffers.reserve(o.buffers.size());
17198	for (const auto &v : o.buffers) { buffers.emplace_back((v) ? new tflite::BufferT (v) : nullptr*); }
17199	metadata.reserve(o.metadata.size());
17200	for (const auto &v : o.metadata) { metadata.emplace_back((v) ? new tflite::MetadataT (v) : nullptr*); }
17201	signature_defs.reserve(o.signature_defs.size());
17202	for (const auto &v : o.signature_defs) { signature_defs.emplace_back((v) ? new tflite::SignatureDefT (v) : nullptr*); }
17203	}
17204
17205	inline ModelT &ModelT::operator=(ModelT o) FLATBUFFERS_NOEXCEPT {
17206	std::swap(version, o.version);
17207	std::swap(operator_codes, o.operator_codes);
17208	std::swap(subgraphs, o.subgraphs);
17209	std::swap(description, o.description);
17210	std::swap(buffers, o.buffers);
17211	std::swap(metadata_buffer, o.metadata_buffer);
17212	std::swap(metadata, o.metadata);
17213	std::swap(signature_defs, o.signature_defs);
17214	return *this;
17215	}
17216
17217	inline ModelT Model::UnPack(const* flatbuffers::resolver_function_t _resolver) const* {
17218	auto _o = std::unique_ptr<ModelT>(new ModelT ());
17219	UnPackTo(_o.get(), _resolver);
17220	return _o.release();
17221	}
17222
17223	inline void Model::UnPackTo(ModelT _o, const* flatbuffers::resolver_function_t _resolver) const* {
17224	(void)_o;
17225	(void)_resolver;
17226	{ auto _e = version(); _o->version = _e; }
17227	{ auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->operator_codes [_i]) { _e->Get(_i)->UnPackTo(_o->operator_codes [_i].get(), _resolver); } else { _o->operator_codes [_i] = std::unique_ptr<tflite::OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17228	{ auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->subgraphs [_i]) { _e->Get(_i)->UnPackTo(_o->subgraphs [_i].get(), _resolver); } else { _o->subgraphs [_i] = std::unique_ptr<tflite::SubGraphT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17229	{ auto _e = description(); if (_e) _o->description = _e->str(); }
17230	{ auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->buffers [_i]) { _e->Get(_i)->UnPackTo(_o->buffers [_i].get(), _resolver); } else { _o->buffers [_i] = std::unique_ptr<tflite::BufferT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17231	{ auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { _o->metadata_buffer [_i] = _e->Get(_i); } } }
17232	{ auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->metadata [_i]) { _e->Get(_i)->UnPackTo(_o->metadata [_i].get(), _resolver); } else { _o->metadata [_i] = std::unique_ptr<tflite::MetadataT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17233	{ auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (flatbuffers::uoffset_t _i = `0`; _i < _e->size(); _i++) { if(_o->signature_defs [_i]) { _e->Get(_i)->UnPackTo(_o->signature_defs [_i].get(), _resolver); } else { _o->signature_defs [_i] = std::unique_ptr<tflite::SignatureDefT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17234	}
17235
17236	inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17237	return CreateModel(_fbb, _o, _rehasher);
17238	}
17239
17240	inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT _o, const* flatbuffers::rehasher_function_t *_rehasher) {
17241	(void)_rehasher;
17242	(void)_o;
17243	struct _VectorArgs { flatbuffers::FlatBufferBuilder __fbb; const* ModelT* __o; const flatbuffers::rehasher_function_t __rehasher; } _va = { &_fbb, _o, _rehasher}; (void*)_va;
17244	auto _version = _o->version;
17245	auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs __va) { return* CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes [i].get(), __va->__rehasher); }, &_va ) : `0`;
17246	auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs __va) { return* CreateSubGraph(*__va->__fbb, __va->__o->subgraphs [i].get(), __va->__rehasher); }, &_va ) : `0`;
17247	auto _description = _o->description.empty() ? `0` : _fbb.CreateString(_o->description);
17248	auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs __va) { return* CreateBuffer(*__va->__fbb, __va->__o->buffers [i].get(), __va->__rehasher); }, &_va ) : `0`;
17249	auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : `0`;
17250	auto _metadata = _o->metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>> (_o->metadata.size(), [](size_t i, _VectorArgs __va) { return* CreateMetadata(*__va->__fbb, __va->__o->metadata [i].get(), __va->__rehasher); }, &_va ) : `0`;
17251	auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>> (_o->signature_defs.size(), [](size_t i, _VectorArgs __va) { return* CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs [i].get(), __va->__rehasher); }, &_va ) : `0`;
17252	return tflite::CreateModel(
17253	_fbb,
17254	_version,
17255	_operator_codes,
17256	_subgraphs,
17257	_description,
17258	_buffers,
17259	_metadata_buffer,
17260	_metadata,
17261	_signature_defs);
17262	}
17263
17264	inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
17265	switch (type) {
17266	case QuantizationDetails_NONE: {
17267	return true;
17268	}
17269	case QuantizationDetails_CustomQuantization: {
17270	auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
17271	return verifier.VerifyTable(ptr);
17272	}
17273	default: return true;
17274	}
17275	}
17276
17277	inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
17278	if (!values \|\| !types) return !values && !types;
17279	if (values->size() != types->size()) return false;
17280	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
17281	if (!VerifyQuantizationDetails(
17282	verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
17283	return false;
17284	}
17285	}
17286	return true;
17287	}
17288
17289	inline void QuantizationDetailsUnion::UnPack(const* void obj, QuantizationDetails type, const* flatbuffers::resolver_function_t *resolver) {
17290	(void)resolver;
17291	switch (type) {
17292	case QuantizationDetails_CustomQuantization: {
17293	auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
17294	return ptr->UnPack(resolver);
17295	}
17296	default: return nullptr;
17297	}
17298	}
17299
17300	inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
17301	(void)_rehasher;
17302	switch (type) {
17303	case QuantizationDetails_CustomQuantization: {
17304	auto ptr = reinterpret_cast<const tflite::CustomQuantizationT *>(value);
17305	return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
17306	}
17307	default: return `0`;
17308	}
17309	}
17310
17311	inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u) : type(u.type), value(nullptr) {
17312	switch (type) {
17313	case QuantizationDetails_CustomQuantization: {
17314	value = new tflite::CustomQuantizationT (*reinterpret_cast<tflite::CustomQuantizationT *>(u.value));
17315	break;
17316	}
17317	default:
17318	break;
17319	}
17320	}
17321
17322	inline void QuantizationDetailsUnion::Reset() {
17323	switch (type) {
17324	case QuantizationDetails_CustomQuantization: {
17325	auto ptr = reinterpret_cast<tflite::CustomQuantizationT *>(value);
17326	delete ptr;
17327	break;
17328	}
17329	default: break;
17330	}
17331	value = nullptr;
17332	type = QuantizationDetails_NONE;
17333	}
17334
17335	inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) {
17336	switch (type) {
17337	case SparseIndexVector_NONE: {
17338	return true;
17339	}
17340	case SparseIndexVector_Int32Vector: {
17341	auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
17342	return verifier.VerifyTable(ptr);
17343	}
17344	case SparseIndexVector_Uint16Vector: {
17345	auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
17346	return verifier.VerifyTable(ptr);
17347	}
17348	case SparseIndexVector_Uint8Vector: {
17349	auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
17350	return verifier.VerifyTable(ptr);
17351	}
17352	default: return true;
17353	}
17354	}
17355
17356	inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
17357	if (!values \|\| !types) return !values && !types;
17358	if (values->size() != types->size()) return false;
17359	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
17360	if (!VerifySparseIndexVector(
17361	verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i))) {
17362	return false;
17363	}
17364	}
17365	return true;
17366	}
17367
17368	inline void SparseIndexVectorUnion::UnPack(const* void obj, SparseIndexVector type, const* flatbuffers::resolver_function_t *resolver) {
17369	(void)resolver;
17370	switch (type) {
17371	case SparseIndexVector_Int32Vector: {
17372	auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
17373	return ptr->UnPack(resolver);
17374	}
17375	case SparseIndexVector_Uint16Vector: {
17376	auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
17377	return ptr->UnPack(resolver);
17378	}
17379	case SparseIndexVector_Uint8Vector: {
17380	auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
17381	return ptr->UnPack(resolver);
17382	}
17383	default: return nullptr;
17384	}
17385	}
17386
17387	inline flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
17388	(void)_rehasher;
17389	switch (type) {
17390	case SparseIndexVector_Int32Vector: {
17391	auto ptr = reinterpret_cast<const tflite::Int32VectorT *>(value);
17392	return CreateInt32Vector(_fbb, ptr, _rehasher).Union();
17393	}
17394	case SparseIndexVector_Uint16Vector: {
17395	auto ptr = reinterpret_cast<const tflite::Uint16VectorT *>(value);
17396	return CreateUint16Vector(_fbb, ptr, _rehasher).Union();
17397	}
17398	case SparseIndexVector_Uint8Vector: {
17399	auto ptr = reinterpret_cast<const tflite::Uint8VectorT *>(value);
17400	return CreateUint8Vector(_fbb, ptr, _rehasher).Union();
17401	}
17402	default: return `0`;
17403	}
17404	}
17405
17406	inline SparseIndexVectorUnion::SparseIndexVectorUnion(const SparseIndexVectorUnion &u) : type(u.type), value(nullptr) {
17407	switch (type) {
17408	case SparseIndexVector_Int32Vector: {
17409	value = new tflite::Int32VectorT (*reinterpret_cast<tflite::Int32VectorT *>(u.value));
17410	break;
17411	}
17412	case SparseIndexVector_Uint16Vector: {
17413	value = new tflite::Uint16VectorT (*reinterpret_cast<tflite::Uint16VectorT *>(u.value));
17414	break;
17415	}
17416	case SparseIndexVector_Uint8Vector: {
17417	value = new tflite::Uint8VectorT (*reinterpret_cast<tflite::Uint8VectorT *>(u.value));
17418	break;
17419	}
17420	default:
17421	break;
17422	}
17423	}
17424
17425	inline void SparseIndexVectorUnion::Reset() {
17426	switch (type) {
17427	case SparseIndexVector_Int32Vector: {
17428	auto ptr = reinterpret_cast<tflite::Int32VectorT *>(value);
17429	delete ptr;
17430	break;
17431	}
17432	case SparseIndexVector_Uint16Vector: {
17433	auto ptr = reinterpret_cast<tflite::Uint16VectorT *>(value);
17434	delete ptr;
17435	break;
17436	}
17437	case SparseIndexVector_Uint8Vector: {
17438	auto ptr = reinterpret_cast<tflite::Uint8VectorT *>(value);
17439	delete ptr;
17440	break;
17441	}
17442	default: break;
17443	}
17444	value = nullptr;
17445	type = SparseIndexVector_NONE;
17446	}
17447
17448	inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
17449	switch (type) {
17450	case BuiltinOptions_NONE: {
17451	return true;
17452	}
17453	case BuiltinOptions_Conv2DOptions: {
17454	auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
17455	return verifier.VerifyTable(ptr);
17456	}
17457	case BuiltinOptions_DepthwiseConv2DOptions: {
17458	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
17459	return verifier.VerifyTable(ptr);
17460	}
17461	case BuiltinOptions_ConcatEmbeddingsOptions: {
17462	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
17463	return verifier.VerifyTable(ptr);
17464	}
17465	case BuiltinOptions_LSHProjectionOptions: {
17466	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
17467	return verifier.VerifyTable(ptr);
17468	}
17469	case BuiltinOptions_Pool2DOptions: {
17470	auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
17471	return verifier.VerifyTable(ptr);
17472	}
17473	case BuiltinOptions_SVDFOptions: {
17474	auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
17475	return verifier.VerifyTable(ptr);
17476	}
17477	case BuiltinOptions_RNNOptions: {
17478	auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
17479	return verifier.VerifyTable(ptr);
17480	}
17481	case BuiltinOptions_FullyConnectedOptions: {
17482	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
17483	return verifier.VerifyTable(ptr);
17484	}
17485	case BuiltinOptions_SoftmaxOptions: {
17486	auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
17487	return verifier.VerifyTable(ptr);
17488	}
17489	case BuiltinOptions_ConcatenationOptions: {
17490	auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
17491	return verifier.VerifyTable(ptr);
17492	}
17493	case BuiltinOptions_AddOptions: {
17494	auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
17495	return verifier.VerifyTable(ptr);
17496	}
17497	case BuiltinOptions_L2NormOptions: {
17498	auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
17499	return verifier.VerifyTable(ptr);
17500	}
17501	case BuiltinOptions_LocalResponseNormalizationOptions: {
17502	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
17503	return verifier.VerifyTable(ptr);
17504	}
17505	case BuiltinOptions_LSTMOptions: {
17506	auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
17507	return verifier.VerifyTable(ptr);
17508	}
17509	case BuiltinOptions_ResizeBilinearOptions: {
17510	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
17511	return verifier.VerifyTable(ptr);
17512	}
17513	case BuiltinOptions_CallOptions: {
17514	auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
17515	return verifier.VerifyTable(ptr);
17516	}
17517	case BuiltinOptions_ReshapeOptions: {
17518	auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
17519	return verifier.VerifyTable(ptr);
17520	}
17521	case BuiltinOptions_SkipGramOptions: {
17522	auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
17523	return verifier.VerifyTable(ptr);
17524	}
17525	case BuiltinOptions_SpaceToDepthOptions: {
17526	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
17527	return verifier.VerifyTable(ptr);
17528	}
17529	case BuiltinOptions_EmbeddingLookupSparseOptions: {
17530	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
17531	return verifier.VerifyTable(ptr);
17532	}
17533	case BuiltinOptions_MulOptions: {
17534	auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
17535	return verifier.VerifyTable(ptr);
17536	}
17537	case BuiltinOptions_PadOptions: {
17538	auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
17539	return verifier.VerifyTable(ptr);
17540	}
17541	case BuiltinOptions_GatherOptions: {
17542	auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
17543	return verifier.VerifyTable(ptr);
17544	}
17545	case BuiltinOptions_BatchToSpaceNDOptions: {
17546	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
17547	return verifier.VerifyTable(ptr);
17548	}
17549	case BuiltinOptions_SpaceToBatchNDOptions: {
17550	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
17551	return verifier.VerifyTable(ptr);
17552	}
17553	case BuiltinOptions_TransposeOptions: {
17554	auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
17555	return verifier.VerifyTable(ptr);
17556	}
17557	case BuiltinOptions_ReducerOptions: {
17558	auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
17559	return verifier.VerifyTable(ptr);
17560	}
17561	case BuiltinOptions_SubOptions: {
17562	auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
17563	return verifier.VerifyTable(ptr);
17564	}
17565	case BuiltinOptions_DivOptions: {
17566	auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
17567	return verifier.VerifyTable(ptr);
17568	}
17569	case BuiltinOptions_SqueezeOptions: {
17570	auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
17571	return verifier.VerifyTable(ptr);
17572	}
17573	case BuiltinOptions_SequenceRNNOptions: {
17574	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
17575	return verifier.VerifyTable(ptr);
17576	}
17577	case BuiltinOptions_StridedSliceOptions: {
17578	auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
17579	return verifier.VerifyTable(ptr);
17580	}
17581	case BuiltinOptions_ExpOptions: {
17582	auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
17583	return verifier.VerifyTable(ptr);
17584	}
17585	case BuiltinOptions_TopKV2Options: {
17586	auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
17587	return verifier.VerifyTable(ptr);
17588	}
17589	case BuiltinOptions_SplitOptions: {
17590	auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
17591	return verifier.VerifyTable(ptr);
17592	}
17593	case BuiltinOptions_LogSoftmaxOptions: {
17594	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
17595	return verifier.VerifyTable(ptr);
17596	}
17597	case BuiltinOptions_CastOptions: {
17598	auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
17599	return verifier.VerifyTable(ptr);
17600	}
17601	case BuiltinOptions_DequantizeOptions: {
17602	auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
17603	return verifier.VerifyTable(ptr);
17604	}
17605	case BuiltinOptions_MaximumMinimumOptions: {
17606	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
17607	return verifier.VerifyTable(ptr);
17608	}
17609	case BuiltinOptions_ArgMaxOptions: {
17610	auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
17611	return verifier.VerifyTable(ptr);
17612	}
17613	case BuiltinOptions_LessOptions: {
17614	auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
17615	return verifier.VerifyTable(ptr);
17616	}
17617	case BuiltinOptions_NegOptions: {
17618	auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
17619	return verifier.VerifyTable(ptr);
17620	}
17621	case BuiltinOptions_PadV2Options: {
17622	auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
17623	return verifier.VerifyTable(ptr);
17624	}
17625	case BuiltinOptions_GreaterOptions: {
17626	auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
17627	return verifier.VerifyTable(ptr);
17628	}
17629	case BuiltinOptions_GreaterEqualOptions: {
17630	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
17631	return verifier.VerifyTable(ptr);
17632	}
17633	case BuiltinOptions_LessEqualOptions: {
17634	auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
17635	return verifier.VerifyTable(ptr);
17636	}
17637	case BuiltinOptions_SelectOptions: {
17638	auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
17639	return verifier.VerifyTable(ptr);
17640	}
17641	case BuiltinOptions_SliceOptions: {
17642	auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
17643	return verifier.VerifyTable(ptr);
17644	}
17645	case BuiltinOptions_TransposeConvOptions: {
17646	auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
17647	return verifier.VerifyTable(ptr);
17648	}
17649	case BuiltinOptions_SparseToDenseOptions: {
17650	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
17651	return verifier.VerifyTable(ptr);
17652	}
17653	case BuiltinOptions_TileOptions: {
17654	auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
17655	return verifier.VerifyTable(ptr);
17656	}
17657	case BuiltinOptions_ExpandDimsOptions: {
17658	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
17659	return verifier.VerifyTable(ptr);
17660	}
17661	case BuiltinOptions_EqualOptions: {
17662	auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
17663	return verifier.VerifyTable(ptr);
17664	}
17665	case BuiltinOptions_NotEqualOptions: {
17666	auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
17667	return verifier.VerifyTable(ptr);
17668	}
17669	case BuiltinOptions_ShapeOptions: {
17670	auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
17671	return verifier.VerifyTable(ptr);
17672	}
17673	case BuiltinOptions_PowOptions: {
17674	auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
17675	return verifier.VerifyTable(ptr);
17676	}
17677	case BuiltinOptions_ArgMinOptions: {
17678	auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
17679	return verifier.VerifyTable(ptr);
17680	}
17681	case BuiltinOptions_FakeQuantOptions: {
17682	auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
17683	return verifier.VerifyTable(ptr);
17684	}
17685	case BuiltinOptions_PackOptions: {
17686	auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
17687	return verifier.VerifyTable(ptr);
17688	}
17689	case BuiltinOptions_LogicalOrOptions: {
17690	auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
17691	return verifier.VerifyTable(ptr);
17692	}
17693	case BuiltinOptions_OneHotOptions: {
17694	auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
17695	return verifier.VerifyTable(ptr);
17696	}
17697	case BuiltinOptions_LogicalAndOptions: {
17698	auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
17699	return verifier.VerifyTable(ptr);
17700	}
17701	case BuiltinOptions_LogicalNotOptions: {
17702	auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
17703	return verifier.VerifyTable(ptr);
17704	}
17705	case BuiltinOptions_UnpackOptions: {
17706	auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
17707	return verifier.VerifyTable(ptr);
17708	}
17709	case BuiltinOptions_FloorDivOptions: {
17710	auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
17711	return verifier.VerifyTable(ptr);
17712	}
17713	case BuiltinOptions_SquareOptions: {
17714	auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
17715	return verifier.VerifyTable(ptr);
17716	}
17717	case BuiltinOptions_ZerosLikeOptions: {
17718	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
17719	return verifier.VerifyTable(ptr);
17720	}
17721	case BuiltinOptions_FillOptions: {
17722	auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
17723	return verifier.VerifyTable(ptr);
17724	}
17725	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
17726	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
17727	return verifier.VerifyTable(ptr);
17728	}
17729	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
17730	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
17731	return verifier.VerifyTable(ptr);
17732	}
17733	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
17734	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
17735	return verifier.VerifyTable(ptr);
17736	}
17737	case BuiltinOptions_FloorModOptions: {
17738	auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
17739	return verifier.VerifyTable(ptr);
17740	}
17741	case BuiltinOptions_RangeOptions: {
17742	auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
17743	return verifier.VerifyTable(ptr);
17744	}
17745	case BuiltinOptions_ResizeNearestNeighborOptions: {
17746	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
17747	return verifier.VerifyTable(ptr);
17748	}
17749	case BuiltinOptions_LeakyReluOptions: {
17750	auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
17751	return verifier.VerifyTable(ptr);
17752	}
17753	case BuiltinOptions_SquaredDifferenceOptions: {
17754	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
17755	return verifier.VerifyTable(ptr);
17756	}
17757	case BuiltinOptions_MirrorPadOptions: {
17758	auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
17759	return verifier.VerifyTable(ptr);
17760	}
17761	case BuiltinOptions_AbsOptions: {
17762	auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
17763	return verifier.VerifyTable(ptr);
17764	}
17765	case BuiltinOptions_SplitVOptions: {
17766	auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
17767	return verifier.VerifyTable(ptr);
17768	}
17769	case BuiltinOptions_UniqueOptions: {
17770	auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
17771	return verifier.VerifyTable(ptr);
17772	}
17773	case BuiltinOptions_ReverseV2Options: {
17774	auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
17775	return verifier.VerifyTable(ptr);
17776	}
17777	case BuiltinOptions_AddNOptions: {
17778	auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
17779	return verifier.VerifyTable(ptr);
17780	}
17781	case BuiltinOptions_GatherNdOptions: {
17782	auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
17783	return verifier.VerifyTable(ptr);
17784	}
17785	case BuiltinOptions_CosOptions: {
17786	auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
17787	return verifier.VerifyTable(ptr);
17788	}
17789	case BuiltinOptions_WhereOptions: {
17790	auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
17791	return verifier.VerifyTable(ptr);
17792	}
17793	case BuiltinOptions_RankOptions: {
17794	auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
17795	return verifier.VerifyTable(ptr);
17796	}
17797	case BuiltinOptions_ReverseSequenceOptions: {
17798	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
17799	return verifier.VerifyTable(ptr);
17800	}
17801	case BuiltinOptions_MatrixDiagOptions: {
17802	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
17803	return verifier.VerifyTable(ptr);
17804	}
17805	case BuiltinOptions_QuantizeOptions: {
17806	auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
17807	return verifier.VerifyTable(ptr);
17808	}
17809	case BuiltinOptions_MatrixSetDiagOptions: {
17810	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
17811	return verifier.VerifyTable(ptr);
17812	}
17813	case BuiltinOptions_HardSwishOptions: {
17814	auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
17815	return verifier.VerifyTable(ptr);
17816	}
17817	case BuiltinOptions_IfOptions: {
17818	auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
17819	return verifier.VerifyTable(ptr);
17820	}
17821	case BuiltinOptions_WhileOptions: {
17822	auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
17823	return verifier.VerifyTable(ptr);
17824	}
17825	case BuiltinOptions_DepthToSpaceOptions: {
17826	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
17827	return verifier.VerifyTable(ptr);
17828	}
17829	case BuiltinOptions_NonMaxSuppressionV4Options: {
17830	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
17831	return verifier.VerifyTable(ptr);
17832	}
17833	case BuiltinOptions_NonMaxSuppressionV5Options: {
17834	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
17835	return verifier.VerifyTable(ptr);
17836	}
17837	case BuiltinOptions_ScatterNdOptions: {
17838	auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
17839	return verifier.VerifyTable(ptr);
17840	}
17841	case BuiltinOptions_SelectV2Options: {
17842	auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
17843	return verifier.VerifyTable(ptr);
17844	}
17845	case BuiltinOptions_DensifyOptions: {
17846	auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
17847	return verifier.VerifyTable(ptr);
17848	}
17849	case BuiltinOptions_SegmentSumOptions: {
17850	auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
17851	return verifier.VerifyTable(ptr);
17852	}
17853	case BuiltinOptions_BatchMatMulOptions: {
17854	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
17855	return verifier.VerifyTable(ptr);
17856	}
17857	case BuiltinOptions_CumsumOptions: {
17858	auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
17859	return verifier.VerifyTable(ptr);
17860	}
17861	case BuiltinOptions_CallOnceOptions: {
17862	auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
17863	return verifier.VerifyTable(ptr);
17864	}
17865	case BuiltinOptions_BroadcastToOptions: {
17866	auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
17867	return verifier.VerifyTable(ptr);
17868	}
17869	case BuiltinOptions_Rfft2dOptions: {
17870	auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
17871	return verifier.VerifyTable(ptr);
17872	}
17873	case BuiltinOptions_Conv3DOptions: {
17874	auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
17875	return verifier.VerifyTable(ptr);
17876	}
17877	case BuiltinOptions_HashtableOptions: {
17878	auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
17879	return verifier.VerifyTable(ptr);
17880	}
17881	case BuiltinOptions_HashtableFindOptions: {
17882	auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
17883	return verifier.VerifyTable(ptr);
17884	}
17885	case BuiltinOptions_HashtableImportOptions: {
17886	auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
17887	return verifier.VerifyTable(ptr);
17888	}
17889	case BuiltinOptions_HashtableSizeOptions: {
17890	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
17891	return verifier.VerifyTable(ptr);
17892	}
17893	case BuiltinOptions_VarHandleOptions: {
17894	auto ptr = reinterpret_cast<const tflite::VarHandleOptions *>(obj);
17895	return verifier.VerifyTable(ptr);
17896	}
17897	case BuiltinOptions_ReadVariableOptions: {
17898	auto ptr = reinterpret_cast<const tflite::ReadVariableOptions *>(obj);
17899	return verifier.VerifyTable(ptr);
17900	}
17901	case BuiltinOptions_AssignVariableOptions: {
17902	auto ptr = reinterpret_cast<const tflite::AssignVariableOptions *>(obj);
17903	return verifier.VerifyTable(ptr);
17904	}
17905	case BuiltinOptions_RandomOptions: {
17906	auto ptr = reinterpret_cast<const tflite::RandomOptions *>(obj);
17907	return verifier.VerifyTable(ptr);
17908	}
17909	case BuiltinOptions_BucketizeOptions: {
17910	auto ptr = reinterpret_cast<const tflite::BucketizeOptions *>(obj);
17911	return verifier.VerifyTable(ptr);
17912	}
17913	case BuiltinOptions_GeluOptions: {
17914	auto ptr = reinterpret_cast<const tflite::GeluOptions *>(obj);
17915	return verifier.VerifyTable(ptr);
17916	}
17917	case BuiltinOptions_DynamicUpdateSliceOptions: {
17918	auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptions *>(obj);
17919	return verifier.VerifyTable(ptr);
17920	}
17921	case BuiltinOptions_UnsortedSegmentProdOptions: {
17922	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptions *>(obj);
17923	return verifier.VerifyTable(ptr);
17924	}
17925	case BuiltinOptions_UnsortedSegmentMaxOptions: {
17926	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptions *>(obj);
17927	return verifier.VerifyTable(ptr);
17928	}
17929	case BuiltinOptions_UnsortedSegmentMinOptions: {
17930	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptions *>(obj);
17931	return verifier.VerifyTable(ptr);
17932	}
17933	case BuiltinOptions_UnsortedSegmentSumOptions: {
17934	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptions *>(obj);
17935	return verifier.VerifyTable(ptr);
17936	}
17937	case BuiltinOptions_ATan2Options: {
17938	auto ptr = reinterpret_cast<const tflite::ATan2Options *>(obj);
17939	return verifier.VerifyTable(ptr);
17940	}
17941	case BuiltinOptions_SignOptions: {
17942	auto ptr = reinterpret_cast<const tflite::SignOptions *>(obj);
17943	return verifier.VerifyTable(ptr);
17944	}
17945	default: return true;
17946	}
17947	}
17948
17949	inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> values, const* flatbuffers::Vector<uint8_t> *types) {
17950	if (!values \|\| !types) return !values && !types;
17951	if (values->size() != types->size()) return false;
17952	for (flatbuffers::uoffset_t i = `0`; i < values->size(); ++i) {
17953	if (!VerifyBuiltinOptions(
17954	verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
17955	return false;
17956	}
17957	}
17958	return true;
17959	}
17960
17961	inline void BuiltinOptionsUnion::UnPack(const* void obj, BuiltinOptions type, const* flatbuffers::resolver_function_t *resolver) {
17962	(void)resolver;
17963	switch (type) {
17964	case BuiltinOptions_Conv2DOptions: {
17965	auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
17966	return ptr->UnPack(resolver);
17967	}
17968	case BuiltinOptions_DepthwiseConv2DOptions: {
17969	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
17970	return ptr->UnPack(resolver);
17971	}
17972	case BuiltinOptions_ConcatEmbeddingsOptions: {
17973	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
17974	return ptr->UnPack(resolver);
17975	}
17976	case BuiltinOptions_LSHProjectionOptions: {
17977	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
17978	return ptr->UnPack(resolver);
17979	}
17980	case BuiltinOptions_Pool2DOptions: {
17981	auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
17982	return ptr->UnPack(resolver);
17983	}
17984	case BuiltinOptions_SVDFOptions: {
17985	auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
17986	return ptr->UnPack(resolver);
17987	}
17988	case BuiltinOptions_RNNOptions: {
17989	auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
17990	return ptr->UnPack(resolver);
17991	}
17992	case BuiltinOptions_FullyConnectedOptions: {
17993	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
17994	return ptr->UnPack(resolver);
17995	}
17996	case BuiltinOptions_SoftmaxOptions: {
17997	auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
17998	return ptr->UnPack(resolver);
17999	}
18000	case BuiltinOptions_ConcatenationOptions: {
18001	auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
18002	return ptr->UnPack(resolver);
18003	}
18004	case BuiltinOptions_AddOptions: {
18005	auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
18006	return ptr->UnPack(resolver);
18007	}
18008	case BuiltinOptions_L2NormOptions: {
18009	auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
18010	return ptr->UnPack(resolver);
18011	}
18012	case BuiltinOptions_LocalResponseNormalizationOptions: {
18013	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
18014	return ptr->UnPack(resolver);
18015	}
18016	case BuiltinOptions_LSTMOptions: {
18017	auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
18018	return ptr->UnPack(resolver);
18019	}
18020	case BuiltinOptions_ResizeBilinearOptions: {
18021	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
18022	return ptr->UnPack(resolver);
18023	}
18024	case BuiltinOptions_CallOptions: {
18025	auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
18026	return ptr->UnPack(resolver);
18027	}
18028	case BuiltinOptions_ReshapeOptions: {
18029	auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
18030	return ptr->UnPack(resolver);
18031	}
18032	case BuiltinOptions_SkipGramOptions: {
18033	auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
18034	return ptr->UnPack(resolver);
18035	}
18036	case BuiltinOptions_SpaceToDepthOptions: {
18037	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
18038	return ptr->UnPack(resolver);
18039	}
18040	case BuiltinOptions_EmbeddingLookupSparseOptions: {
18041	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
18042	return ptr->UnPack(resolver);
18043	}
18044	case BuiltinOptions_MulOptions: {
18045	auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
18046	return ptr->UnPack(resolver);
18047	}
18048	case BuiltinOptions_PadOptions: {
18049	auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
18050	return ptr->UnPack(resolver);
18051	}
18052	case BuiltinOptions_GatherOptions: {
18053	auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
18054	return ptr->UnPack(resolver);
18055	}
18056	case BuiltinOptions_BatchToSpaceNDOptions: {
18057	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
18058	return ptr->UnPack(resolver);
18059	}
18060	case BuiltinOptions_SpaceToBatchNDOptions: {
18061	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
18062	return ptr->UnPack(resolver);
18063	}
18064	case BuiltinOptions_TransposeOptions: {
18065	auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
18066	return ptr->UnPack(resolver);
18067	}
18068	case BuiltinOptions_ReducerOptions: {
18069	auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
18070	return ptr->UnPack(resolver);
18071	}
18072	case BuiltinOptions_SubOptions: {
18073	auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
18074	return ptr->UnPack(resolver);
18075	}
18076	case BuiltinOptions_DivOptions: {
18077	auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
18078	return ptr->UnPack(resolver);
18079	}
18080	case BuiltinOptions_SqueezeOptions: {
18081	auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
18082	return ptr->UnPack(resolver);
18083	}
18084	case BuiltinOptions_SequenceRNNOptions: {
18085	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
18086	return ptr->UnPack(resolver);
18087	}
18088	case BuiltinOptions_StridedSliceOptions: {
18089	auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
18090	return ptr->UnPack(resolver);
18091	}
18092	case BuiltinOptions_ExpOptions: {
18093	auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
18094	return ptr->UnPack(resolver);
18095	}
18096	case BuiltinOptions_TopKV2Options: {
18097	auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
18098	return ptr->UnPack(resolver);
18099	}
18100	case BuiltinOptions_SplitOptions: {
18101	auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
18102	return ptr->UnPack(resolver);
18103	}
18104	case BuiltinOptions_LogSoftmaxOptions: {
18105	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
18106	return ptr->UnPack(resolver);
18107	}
18108	case BuiltinOptions_CastOptions: {
18109	auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
18110	return ptr->UnPack(resolver);
18111	}
18112	case BuiltinOptions_DequantizeOptions: {
18113	auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
18114	return ptr->UnPack(resolver);
18115	}
18116	case BuiltinOptions_MaximumMinimumOptions: {
18117	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
18118	return ptr->UnPack(resolver);
18119	}
18120	case BuiltinOptions_ArgMaxOptions: {
18121	auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
18122	return ptr->UnPack(resolver);
18123	}
18124	case BuiltinOptions_LessOptions: {
18125	auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
18126	return ptr->UnPack(resolver);
18127	}
18128	case BuiltinOptions_NegOptions: {
18129	auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
18130	return ptr->UnPack(resolver);
18131	}
18132	case BuiltinOptions_PadV2Options: {
18133	auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
18134	return ptr->UnPack(resolver);
18135	}
18136	case BuiltinOptions_GreaterOptions: {
18137	auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
18138	return ptr->UnPack(resolver);
18139	}
18140	case BuiltinOptions_GreaterEqualOptions: {
18141	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
18142	return ptr->UnPack(resolver);
18143	}
18144	case BuiltinOptions_LessEqualOptions: {
18145	auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
18146	return ptr->UnPack(resolver);
18147	}
18148	case BuiltinOptions_SelectOptions: {
18149	auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
18150	return ptr->UnPack(resolver);
18151	}
18152	case BuiltinOptions_SliceOptions: {
18153	auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
18154	return ptr->UnPack(resolver);
18155	}
18156	case BuiltinOptions_TransposeConvOptions: {
18157	auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
18158	return ptr->UnPack(resolver);
18159	}
18160	case BuiltinOptions_SparseToDenseOptions: {
18161	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
18162	return ptr->UnPack(resolver);
18163	}
18164	case BuiltinOptions_TileOptions: {
18165	auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
18166	return ptr->UnPack(resolver);
18167	}
18168	case BuiltinOptions_ExpandDimsOptions: {
18169	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
18170	return ptr->UnPack(resolver);
18171	}
18172	case BuiltinOptions_EqualOptions: {
18173	auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
18174	return ptr->UnPack(resolver);
18175	}
18176	case BuiltinOptions_NotEqualOptions: {
18177	auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
18178	return ptr->UnPack(resolver);
18179	}
18180	case BuiltinOptions_ShapeOptions: {
18181	auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
18182	return ptr->UnPack(resolver);
18183	}
18184	case BuiltinOptions_PowOptions: {
18185	auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
18186	return ptr->UnPack(resolver);
18187	}
18188	case BuiltinOptions_ArgMinOptions: {
18189	auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
18190	return ptr->UnPack(resolver);
18191	}
18192	case BuiltinOptions_FakeQuantOptions: {
18193	auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
18194	return ptr->UnPack(resolver);
18195	}
18196	case BuiltinOptions_PackOptions: {
18197	auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
18198	return ptr->UnPack(resolver);
18199	}
18200	case BuiltinOptions_LogicalOrOptions: {
18201	auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
18202	return ptr->UnPack(resolver);
18203	}
18204	case BuiltinOptions_OneHotOptions: {
18205	auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
18206	return ptr->UnPack(resolver);
18207	}
18208	case BuiltinOptions_LogicalAndOptions: {
18209	auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
18210	return ptr->UnPack(resolver);
18211	}
18212	case BuiltinOptions_LogicalNotOptions: {
18213	auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
18214	return ptr->UnPack(resolver);
18215	}
18216	case BuiltinOptions_UnpackOptions: {
18217	auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
18218	return ptr->UnPack(resolver);
18219	}
18220	case BuiltinOptions_FloorDivOptions: {
18221	auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
18222	return ptr->UnPack(resolver);
18223	}
18224	case BuiltinOptions_SquareOptions: {
18225	auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
18226	return ptr->UnPack(resolver);
18227	}
18228	case BuiltinOptions_ZerosLikeOptions: {
18229	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
18230	return ptr->UnPack(resolver);
18231	}
18232	case BuiltinOptions_FillOptions: {
18233	auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
18234	return ptr->UnPack(resolver);
18235	}
18236	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
18237	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
18238	return ptr->UnPack(resolver);
18239	}
18240	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
18241	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
18242	return ptr->UnPack(resolver);
18243	}
18244	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
18245	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
18246	return ptr->UnPack(resolver);
18247	}
18248	case BuiltinOptions_FloorModOptions: {
18249	auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
18250	return ptr->UnPack(resolver);
18251	}
18252	case BuiltinOptions_RangeOptions: {
18253	auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
18254	return ptr->UnPack(resolver);
18255	}
18256	case BuiltinOptions_ResizeNearestNeighborOptions: {
18257	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
18258	return ptr->UnPack(resolver);
18259	}
18260	case BuiltinOptions_LeakyReluOptions: {
18261	auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
18262	return ptr->UnPack(resolver);
18263	}
18264	case BuiltinOptions_SquaredDifferenceOptions: {
18265	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
18266	return ptr->UnPack(resolver);
18267	}
18268	case BuiltinOptions_MirrorPadOptions: {
18269	auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
18270	return ptr->UnPack(resolver);
18271	}
18272	case BuiltinOptions_AbsOptions: {
18273	auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
18274	return ptr->UnPack(resolver);
18275	}
18276	case BuiltinOptions_SplitVOptions: {
18277	auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
18278	return ptr->UnPack(resolver);
18279	}
18280	case BuiltinOptions_UniqueOptions: {
18281	auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
18282	return ptr->UnPack(resolver);
18283	}
18284	case BuiltinOptions_ReverseV2Options: {
18285	auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
18286	return ptr->UnPack(resolver);
18287	}
18288	case BuiltinOptions_AddNOptions: {
18289	auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
18290	return ptr->UnPack(resolver);
18291	}
18292	case BuiltinOptions_GatherNdOptions: {
18293	auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
18294	return ptr->UnPack(resolver);
18295	}
18296	case BuiltinOptions_CosOptions: {
18297	auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
18298	return ptr->UnPack(resolver);
18299	}
18300	case BuiltinOptions_WhereOptions: {
18301	auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
18302	return ptr->UnPack(resolver);
18303	}
18304	case BuiltinOptions_RankOptions: {
18305	auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
18306	return ptr->UnPack(resolver);
18307	}
18308	case BuiltinOptions_ReverseSequenceOptions: {
18309	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
18310	return ptr->UnPack(resolver);
18311	}
18312	case BuiltinOptions_MatrixDiagOptions: {
18313	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
18314	return ptr->UnPack(resolver);
18315	}
18316	case BuiltinOptions_QuantizeOptions: {
18317	auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
18318	return ptr->UnPack(resolver);
18319	}
18320	case BuiltinOptions_MatrixSetDiagOptions: {
18321	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
18322	return ptr->UnPack(resolver);
18323	}
18324	case BuiltinOptions_HardSwishOptions: {
18325	auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
18326	return ptr->UnPack(resolver);
18327	}
18328	case BuiltinOptions_IfOptions: {
18329	auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
18330	return ptr->UnPack(resolver);
18331	}
18332	case BuiltinOptions_WhileOptions: {
18333	auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
18334	return ptr->UnPack(resolver);
18335	}
18336	case BuiltinOptions_DepthToSpaceOptions: {
18337	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
18338	return ptr->UnPack(resolver);
18339	}
18340	case BuiltinOptions_NonMaxSuppressionV4Options: {
18341	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
18342	return ptr->UnPack(resolver);
18343	}
18344	case BuiltinOptions_NonMaxSuppressionV5Options: {
18345	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
18346	return ptr->UnPack(resolver);
18347	}
18348	case BuiltinOptions_ScatterNdOptions: {
18349	auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
18350	return ptr->UnPack(resolver);
18351	}
18352	case BuiltinOptions_SelectV2Options: {
18353	auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
18354	return ptr->UnPack(resolver);
18355	}
18356	case BuiltinOptions_DensifyOptions: {
18357	auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
18358	return ptr->UnPack(resolver);
18359	}
18360	case BuiltinOptions_SegmentSumOptions: {
18361	auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
18362	return ptr->UnPack(resolver);
18363	}
18364	case BuiltinOptions_BatchMatMulOptions: {
18365	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
18366	return ptr->UnPack(resolver);
18367	}
18368	case BuiltinOptions_CumsumOptions: {
18369	auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
18370	return ptr->UnPack(resolver);
18371	}
18372	case BuiltinOptions_CallOnceOptions: {
18373	auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
18374	return ptr->UnPack(resolver);
18375	}
18376	case BuiltinOptions_BroadcastToOptions: {
18377	auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
18378	return ptr->UnPack(resolver);
18379	}
18380	case BuiltinOptions_Rfft2dOptions: {
18381	auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
18382	return ptr->UnPack(resolver);
18383	}
18384	case BuiltinOptions_Conv3DOptions: {
18385	auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
18386	return ptr->UnPack(resolver);
18387	}
18388	case BuiltinOptions_HashtableOptions: {
18389	auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
18390	return ptr->UnPack(resolver);
18391	}
18392	case BuiltinOptions_HashtableFindOptions: {
18393	auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
18394	return ptr->UnPack(resolver);
18395	}
18396	case BuiltinOptions_HashtableImportOptions: {
18397	auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
18398	return ptr->UnPack(resolver);
18399	}
18400	case BuiltinOptions_HashtableSizeOptions: {
18401	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
18402	return ptr->UnPack(resolver);
18403	}
18404	case BuiltinOptions_VarHandleOptions: {
18405	auto ptr = reinterpret_cast<const tflite::VarHandleOptions *>(obj);
18406	return ptr->UnPack(resolver);
18407	}
18408	case BuiltinOptions_ReadVariableOptions: {
18409	auto ptr = reinterpret_cast<const tflite::ReadVariableOptions *>(obj);
18410	return ptr->UnPack(resolver);
18411	}
18412	case BuiltinOptions_AssignVariableOptions: {
18413	auto ptr = reinterpret_cast<const tflite::AssignVariableOptions *>(obj);
18414	return ptr->UnPack(resolver);
18415	}
18416	case BuiltinOptions_RandomOptions: {
18417	auto ptr = reinterpret_cast<const tflite::RandomOptions *>(obj);
18418	return ptr->UnPack(resolver);
18419	}
18420	case BuiltinOptions_BucketizeOptions: {
18421	auto ptr = reinterpret_cast<const tflite::BucketizeOptions *>(obj);
18422	return ptr->UnPack(resolver);
18423	}
18424	case BuiltinOptions_GeluOptions: {
18425	auto ptr = reinterpret_cast<const tflite::GeluOptions *>(obj);
18426	return ptr->UnPack(resolver);
18427	}
18428	case BuiltinOptions_DynamicUpdateSliceOptions: {
18429	auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptions *>(obj);
18430	return ptr->UnPack(resolver);
18431	}
18432	case BuiltinOptions_UnsortedSegmentProdOptions: {
18433	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptions *>(obj);
18434	return ptr->UnPack(resolver);
18435	}
18436	case BuiltinOptions_UnsortedSegmentMaxOptions: {
18437	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptions *>(obj);
18438	return ptr->UnPack(resolver);
18439	}
18440	case BuiltinOptions_UnsortedSegmentMinOptions: {
18441	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptions *>(obj);
18442	return ptr->UnPack(resolver);
18443	}
18444	case BuiltinOptions_UnsortedSegmentSumOptions: {
18445	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptions *>(obj);
18446	return ptr->UnPack(resolver);
18447	}
18448	case BuiltinOptions_ATan2Options: {
18449	auto ptr = reinterpret_cast<const tflite::ATan2Options *>(obj);
18450	return ptr->UnPack(resolver);
18451	}
18452	case BuiltinOptions_SignOptions: {
18453	auto ptr = reinterpret_cast<const tflite::SignOptions *>(obj);
18454	return ptr->UnPack(resolver);
18455	}
18456	default: return nullptr;
18457	}
18458	}
18459
18460	inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t _rehasher) const* {
18461	(void)_rehasher;
18462	switch (type) {
18463	case BuiltinOptions_Conv2DOptions: {
18464	auto ptr = reinterpret_cast<const tflite::Conv2DOptionsT *>(value);
18465	return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
18466	}
18467	case BuiltinOptions_DepthwiseConv2DOptions: {
18468	auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptionsT *>(value);
18469	return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
18470	}
18471	case BuiltinOptions_ConcatEmbeddingsOptions: {
18472	auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT *>(value);
18473	return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
18474	}
18475	case BuiltinOptions_LSHProjectionOptions: {
18476	auto ptr = reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value);
18477	return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
18478	}
18479	case BuiltinOptions_Pool2DOptions: {
18480	auto ptr = reinterpret_cast<const tflite::Pool2DOptionsT *>(value);
18481	return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
18482	}
18483	case BuiltinOptions_SVDFOptions: {
18484	auto ptr = reinterpret_cast<const tflite::SVDFOptionsT *>(value);
18485	return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
18486	}
18487	case BuiltinOptions_RNNOptions: {
18488	auto ptr = reinterpret_cast<const tflite::RNNOptionsT *>(value);
18489	return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
18490	}
18491	case BuiltinOptions_FullyConnectedOptions: {
18492	auto ptr = reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value);
18493	return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
18494	}
18495	case BuiltinOptions_SoftmaxOptions: {
18496	auto ptr = reinterpret_cast<const tflite::SoftmaxOptionsT *>(value);
18497	return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
18498	}
18499	case BuiltinOptions_ConcatenationOptions: {
18500	auto ptr = reinterpret_cast<const tflite::ConcatenationOptionsT *>(value);
18501	return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
18502	}
18503	case BuiltinOptions_AddOptions: {
18504	auto ptr = reinterpret_cast<const tflite::AddOptionsT *>(value);
18505	return CreateAddOptions(_fbb, ptr, _rehasher).Union();
18506	}
18507	case BuiltinOptions_L2NormOptions: {
18508	auto ptr = reinterpret_cast<const tflite::L2NormOptionsT *>(value);
18509	return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
18510	}
18511	case BuiltinOptions_LocalResponseNormalizationOptions: {
18512	auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT *>(value);
18513	return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
18514	}
18515	case BuiltinOptions_LSTMOptions: {
18516	auto ptr = reinterpret_cast<const tflite::LSTMOptionsT *>(value);
18517	return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
18518	}
18519	case BuiltinOptions_ResizeBilinearOptions: {
18520	auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value);
18521	return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
18522	}
18523	case BuiltinOptions_CallOptions: {
18524	auto ptr = reinterpret_cast<const tflite::CallOptionsT *>(value);
18525	return CreateCallOptions(_fbb, ptr, _rehasher).Union();
18526	}
18527	case BuiltinOptions_ReshapeOptions: {
18528	auto ptr = reinterpret_cast<const tflite::ReshapeOptionsT *>(value);
18529	return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
18530	}
18531	case BuiltinOptions_SkipGramOptions: {
18532	auto ptr = reinterpret_cast<const tflite::SkipGramOptionsT *>(value);
18533	return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
18534	}
18535	case BuiltinOptions_SpaceToDepthOptions: {
18536	auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value);
18537	return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
18538	}
18539	case BuiltinOptions_EmbeddingLookupSparseOptions: {
18540	auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT *>(value);
18541	return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
18542	}
18543	case BuiltinOptions_MulOptions: {
18544	auto ptr = reinterpret_cast<const tflite::MulOptionsT *>(value);
18545	return CreateMulOptions(_fbb, ptr, _rehasher).Union();
18546	}
18547	case BuiltinOptions_PadOptions: {
18548	auto ptr = reinterpret_cast<const tflite::PadOptionsT *>(value);
18549	return CreatePadOptions(_fbb, ptr, _rehasher).Union();
18550	}
18551	case BuiltinOptions_GatherOptions: {
18552	auto ptr = reinterpret_cast<const tflite::GatherOptionsT *>(value);
18553	return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
18554	}
18555	case BuiltinOptions_BatchToSpaceNDOptions: {
18556	auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value);
18557	return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
18558	}
18559	case BuiltinOptions_SpaceToBatchNDOptions: {
18560	auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value);
18561	return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
18562	}
18563	case BuiltinOptions_TransposeOptions: {
18564	auto ptr = reinterpret_cast<const tflite::TransposeOptionsT *>(value);
18565	return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
18566	}
18567	case BuiltinOptions_ReducerOptions: {
18568	auto ptr = reinterpret_cast<const tflite::ReducerOptionsT *>(value);
18569	return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
18570	}
18571	case BuiltinOptions_SubOptions: {
18572	auto ptr = reinterpret_cast<const tflite::SubOptionsT *>(value);
18573	return CreateSubOptions(_fbb, ptr, _rehasher).Union();
18574	}
18575	case BuiltinOptions_DivOptions: {
18576	auto ptr = reinterpret_cast<const tflite::DivOptionsT *>(value);
18577	return CreateDivOptions(_fbb, ptr, _rehasher).Union();
18578	}
18579	case BuiltinOptions_SqueezeOptions: {
18580	auto ptr = reinterpret_cast<const tflite::SqueezeOptionsT *>(value);
18581	return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
18582	}
18583	case BuiltinOptions_SequenceRNNOptions: {
18584	auto ptr = reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value);
18585	return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
18586	}
18587	case BuiltinOptions_StridedSliceOptions: {
18588	auto ptr = reinterpret_cast<const tflite::StridedSliceOptionsT *>(value);
18589	return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
18590	}
18591	case BuiltinOptions_ExpOptions: {
18592	auto ptr = reinterpret_cast<const tflite::ExpOptionsT *>(value);
18593	return CreateExpOptions(_fbb, ptr, _rehasher).Union();
18594	}
18595	case BuiltinOptions_TopKV2Options: {
18596	auto ptr = reinterpret_cast<const tflite::TopKV2OptionsT *>(value);
18597	return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
18598	}
18599	case BuiltinOptions_SplitOptions: {
18600	auto ptr = reinterpret_cast<const tflite::SplitOptionsT *>(value);
18601	return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
18602	}
18603	case BuiltinOptions_LogSoftmaxOptions: {
18604	auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value);
18605	return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
18606	}
18607	case BuiltinOptions_CastOptions: {
18608	auto ptr = reinterpret_cast<const tflite::CastOptionsT *>(value);
18609	return CreateCastOptions(_fbb, ptr, _rehasher).Union();
18610	}
18611	case BuiltinOptions_DequantizeOptions: {
18612	auto ptr = reinterpret_cast<const tflite::DequantizeOptionsT *>(value);
18613	return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
18614	}
18615	case BuiltinOptions_MaximumMinimumOptions: {
18616	auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value);
18617	return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
18618	}
18619	case BuiltinOptions_ArgMaxOptions: {
18620	auto ptr = reinterpret_cast<const tflite::ArgMaxOptionsT *>(value);
18621	return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
18622	}
18623	case BuiltinOptions_LessOptions: {
18624	auto ptr = reinterpret_cast<const tflite::LessOptionsT *>(value);
18625	return CreateLessOptions(_fbb, ptr, _rehasher).Union();
18626	}
18627	case BuiltinOptions_NegOptions: {
18628	auto ptr = reinterpret_cast<const tflite::NegOptionsT *>(value);
18629	return CreateNegOptions(_fbb, ptr, _rehasher).Union();
18630	}
18631	case BuiltinOptions_PadV2Options: {
18632	auto ptr = reinterpret_cast<const tflite::PadV2OptionsT *>(value);
18633	return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
18634	}
18635	case BuiltinOptions_GreaterOptions: {
18636	auto ptr = reinterpret_cast<const tflite::GreaterOptionsT *>(value);
18637	return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
18638	}
18639	case BuiltinOptions_GreaterEqualOptions: {
18640	auto ptr = reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value);
18641	return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
18642	}
18643	case BuiltinOptions_LessEqualOptions: {
18644	auto ptr = reinterpret_cast<const tflite::LessEqualOptionsT *>(value);
18645	return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
18646	}
18647	case BuiltinOptions_SelectOptions: {
18648	auto ptr = reinterpret_cast<const tflite::SelectOptionsT *>(value);
18649	return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
18650	}
18651	case BuiltinOptions_SliceOptions: {
18652	auto ptr = reinterpret_cast<const tflite::SliceOptionsT *>(value);
18653	return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
18654	}
18655	case BuiltinOptions_TransposeConvOptions: {
18656	auto ptr = reinterpret_cast<const tflite::TransposeConvOptionsT *>(value);
18657	return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
18658	}
18659	case BuiltinOptions_SparseToDenseOptions: {
18660	auto ptr = reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value);
18661	return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
18662	}
18663	case BuiltinOptions_TileOptions: {
18664	auto ptr = reinterpret_cast<const tflite::TileOptionsT *>(value);
18665	return CreateTileOptions(_fbb, ptr, _rehasher).Union();
18666	}
18667	case BuiltinOptions_ExpandDimsOptions: {
18668	auto ptr = reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value);
18669	return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
18670	}
18671	case BuiltinOptions_EqualOptions: {
18672	auto ptr = reinterpret_cast<const tflite::EqualOptionsT *>(value);
18673	return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
18674	}
18675	case BuiltinOptions_NotEqualOptions: {
18676	auto ptr = reinterpret_cast<const tflite::NotEqualOptionsT *>(value);
18677	return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
18678	}
18679	case BuiltinOptions_ShapeOptions: {
18680	auto ptr = reinterpret_cast<const tflite::ShapeOptionsT *>(value);
18681	return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
18682	}
18683	case BuiltinOptions_PowOptions: {
18684	auto ptr = reinterpret_cast<const tflite::PowOptionsT *>(value);
18685	return CreatePowOptions(_fbb, ptr, _rehasher).Union();
18686	}
18687	case BuiltinOptions_ArgMinOptions: {
18688	auto ptr = reinterpret_cast<const tflite::ArgMinOptionsT *>(value);
18689	return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
18690	}
18691	case BuiltinOptions_FakeQuantOptions: {
18692	auto ptr = reinterpret_cast<const tflite::FakeQuantOptionsT *>(value);
18693	return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
18694	}
18695	case BuiltinOptions_PackOptions: {
18696	auto ptr = reinterpret_cast<const tflite::PackOptionsT *>(value);
18697	return CreatePackOptions(_fbb, ptr, _rehasher).Union();
18698	}
18699	case BuiltinOptions_LogicalOrOptions: {
18700	auto ptr = reinterpret_cast<const tflite::LogicalOrOptionsT *>(value);
18701	return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
18702	}
18703	case BuiltinOptions_OneHotOptions: {
18704	auto ptr = reinterpret_cast<const tflite::OneHotOptionsT *>(value);
18705	return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
18706	}
18707	case BuiltinOptions_LogicalAndOptions: {
18708	auto ptr = reinterpret_cast<const tflite::LogicalAndOptionsT *>(value);
18709	return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
18710	}
18711	case BuiltinOptions_LogicalNotOptions: {
18712	auto ptr = reinterpret_cast<const tflite::LogicalNotOptionsT *>(value);
18713	return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
18714	}
18715	case BuiltinOptions_UnpackOptions: {
18716	auto ptr = reinterpret_cast<const tflite::UnpackOptionsT *>(value);
18717	return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
18718	}
18719	case BuiltinOptions_FloorDivOptions: {
18720	auto ptr = reinterpret_cast<const tflite::FloorDivOptionsT *>(value);
18721	return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
18722	}
18723	case BuiltinOptions_SquareOptions: {
18724	auto ptr = reinterpret_cast<const tflite::SquareOptionsT *>(value);
18725	return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
18726	}
18727	case BuiltinOptions_ZerosLikeOptions: {
18728	auto ptr = reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value);
18729	return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
18730	}
18731	case BuiltinOptions_FillOptions: {
18732	auto ptr = reinterpret_cast<const tflite::FillOptionsT *>(value);
18733	return CreateFillOptions(_fbb, ptr, _rehasher).Union();
18734	}
18735	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
18736	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT *>(value);
18737	return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
18738	}
18739	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
18740	auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT *>(value);
18741	return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
18742	}
18743	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
18744	auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
18745	return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
18746	}
18747	case BuiltinOptions_FloorModOptions: {
18748	auto ptr = reinterpret_cast<const tflite::FloorModOptionsT *>(value);
18749	return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
18750	}
18751	case BuiltinOptions_RangeOptions: {
18752	auto ptr = reinterpret_cast<const tflite::RangeOptionsT *>(value);
18753	return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
18754	}
18755	case BuiltinOptions_ResizeNearestNeighborOptions: {
18756	auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT *>(value);
18757	return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
18758	}
18759	case BuiltinOptions_LeakyReluOptions: {
18760	auto ptr = reinterpret_cast<const tflite::LeakyReluOptionsT *>(value);
18761	return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
18762	}
18763	case BuiltinOptions_SquaredDifferenceOptions: {
18764	auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptionsT *>(value);
18765	return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
18766	}
18767	case BuiltinOptions_MirrorPadOptions: {
18768	auto ptr = reinterpret_cast<const tflite::MirrorPadOptionsT *>(value);
18769	return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
18770	}
18771	case BuiltinOptions_AbsOptions: {
18772	auto ptr = reinterpret_cast<const tflite::AbsOptionsT *>(value);
18773	return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
18774	}
18775	case BuiltinOptions_SplitVOptions: {
18776	auto ptr = reinterpret_cast<const tflite::SplitVOptionsT *>(value);
18777	return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
18778	}
18779	case BuiltinOptions_UniqueOptions: {
18780	auto ptr = reinterpret_cast<const tflite::UniqueOptionsT *>(value);
18781	return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
18782	}
18783	case BuiltinOptions_ReverseV2Options: {
18784	auto ptr = reinterpret_cast<const tflite::ReverseV2OptionsT *>(value);
18785	return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
18786	}
18787	case BuiltinOptions_AddNOptions: {
18788	auto ptr = reinterpret_cast<const tflite::AddNOptionsT *>(value);
18789	return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
18790	}
18791	case BuiltinOptions_GatherNdOptions: {
18792	auto ptr = reinterpret_cast<const tflite::GatherNdOptionsT *>(value);
18793	return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
18794	}
18795	case BuiltinOptions_CosOptions: {
18796	auto ptr = reinterpret_cast<const tflite::CosOptionsT *>(value);
18797	return CreateCosOptions(_fbb, ptr, _rehasher).Union();
18798	}
18799	case BuiltinOptions_WhereOptions: {
18800	auto ptr = reinterpret_cast<const tflite::WhereOptionsT *>(value);
18801	return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
18802	}
18803	case BuiltinOptions_RankOptions: {
18804	auto ptr = reinterpret_cast<const tflite::RankOptionsT *>(value);
18805	return CreateRankOptions(_fbb, ptr, _rehasher).Union();
18806	}
18807	case BuiltinOptions_ReverseSequenceOptions: {
18808	auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptionsT *>(value);
18809	return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
18810	}
18811	case BuiltinOptions_MatrixDiagOptions: {
18812	auto ptr = reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value);
18813	return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
18814	}
18815	case BuiltinOptions_QuantizeOptions: {
18816	auto ptr = reinterpret_cast<const tflite::QuantizeOptionsT *>(value);
18817	return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
18818	}
18819	case BuiltinOptions_MatrixSetDiagOptions: {
18820	auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value);
18821	return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
18822	}
18823	case BuiltinOptions_HardSwishOptions: {
18824	auto ptr = reinterpret_cast<const tflite::HardSwishOptionsT *>(value);
18825	return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
18826	}
18827	case BuiltinOptions_IfOptions: {
18828	auto ptr = reinterpret_cast<const tflite::IfOptionsT *>(value);
18829	return CreateIfOptions(_fbb, ptr, _rehasher).Union();
18830	}
18831	case BuiltinOptions_WhileOptions: {
18832	auto ptr = reinterpret_cast<const tflite::WhileOptionsT *>(value);
18833	return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
18834	}
18835	case BuiltinOptions_DepthToSpaceOptions: {
18836	auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value);
18837	return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
18838	}
18839	case BuiltinOptions_NonMaxSuppressionV4Options: {
18840	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT *>(value);
18841	return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
18842	}
18843	case BuiltinOptions_NonMaxSuppressionV5Options: {
18844	auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT *>(value);
18845	return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
18846	}
18847	case BuiltinOptions_ScatterNdOptions: {
18848	auto ptr = reinterpret_cast<const tflite::ScatterNdOptionsT *>(value);
18849	return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
18850	}
18851	case BuiltinOptions_SelectV2Options: {
18852	auto ptr = reinterpret_cast<const tflite::SelectV2OptionsT *>(value);
18853	return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
18854	}
18855	case BuiltinOptions_DensifyOptions: {
18856	auto ptr = reinterpret_cast<const tflite::DensifyOptionsT *>(value);
18857	return CreateDensifyOptions(_fbb, ptr, _rehasher).Union();
18858	}
18859	case BuiltinOptions_SegmentSumOptions: {
18860	auto ptr = reinterpret_cast<const tflite::SegmentSumOptionsT *>(value);
18861	return CreateSegmentSumOptions(_fbb, ptr, _rehasher).Union();
18862	}
18863	case BuiltinOptions_BatchMatMulOptions: {
18864	auto ptr = reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value);
18865	return CreateBatchMatMulOptions(_fbb, ptr, _rehasher).Union();
18866	}
18867	case BuiltinOptions_CumsumOptions: {
18868	auto ptr = reinterpret_cast<const tflite::CumsumOptionsT *>(value);
18869	return CreateCumsumOptions(_fbb, ptr, _rehasher).Union();
18870	}
18871	case BuiltinOptions_CallOnceOptions: {
18872	auto ptr = reinterpret_cast<const tflite::CallOnceOptionsT *>(value);
18873	return CreateCallOnceOptions(_fbb, ptr, _rehasher).Union();
18874	}
18875	case BuiltinOptions_BroadcastToOptions: {
18876	auto ptr = reinterpret_cast<const tflite::BroadcastToOptionsT *>(value);
18877	return CreateBroadcastToOptions(_fbb, ptr, _rehasher).Union();
18878	}
18879	case BuiltinOptions_Rfft2dOptions: {
18880	auto ptr = reinterpret_cast<const tflite::Rfft2dOptionsT *>(value);
18881	return CreateRfft2dOptions(_fbb, ptr, _rehasher).Union();
18882	}
18883	case BuiltinOptions_Conv3DOptions: {
18884	auto ptr = reinterpret_cast<const tflite::Conv3DOptionsT *>(value);
18885	return CreateConv3DOptions(_fbb, ptr, _rehasher).Union();
18886	}
18887	case BuiltinOptions_HashtableOptions: {
18888	auto ptr = reinterpret_cast<const tflite::HashtableOptionsT *>(value);
18889	return CreateHashtableOptions(_fbb, ptr, _rehasher).Union();
18890	}
18891	case BuiltinOptions_HashtableFindOptions: {
18892	auto ptr = reinterpret_cast<const tflite::HashtableFindOptionsT *>(value);
18893	return CreateHashtableFindOptions(_fbb, ptr, _rehasher).Union();
18894	}
18895	case BuiltinOptions_HashtableImportOptions: {
18896	auto ptr = reinterpret_cast<const tflite::HashtableImportOptionsT *>(value);
18897	return CreateHashtableImportOptions(_fbb, ptr, _rehasher).Union();
18898	}
18899	case BuiltinOptions_HashtableSizeOptions: {
18900	auto ptr = reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value);
18901	return CreateHashtableSizeOptions(_fbb, ptr, _rehasher).Union();
18902	}
18903	case BuiltinOptions_VarHandleOptions: {
18904	auto ptr = reinterpret_cast<const tflite::VarHandleOptionsT *>(value);
18905	return CreateVarHandleOptions(_fbb, ptr, _rehasher).Union();
18906	}
18907	case BuiltinOptions_ReadVariableOptions: {
18908	auto ptr = reinterpret_cast<const tflite::ReadVariableOptionsT *>(value);
18909	return CreateReadVariableOptions(_fbb, ptr, _rehasher).Union();
18910	}
18911	case BuiltinOptions_AssignVariableOptions: {
18912	auto ptr = reinterpret_cast<const tflite::AssignVariableOptionsT *>(value);
18913	return CreateAssignVariableOptions(_fbb, ptr, _rehasher).Union();
18914	}
18915	case BuiltinOptions_RandomOptions: {
18916	auto ptr = reinterpret_cast<const tflite::RandomOptionsT *>(value);
18917	return CreateRandomOptions(_fbb, ptr, _rehasher).Union();
18918	}
18919	case BuiltinOptions_BucketizeOptions: {
18920	auto ptr = reinterpret_cast<const tflite::BucketizeOptionsT *>(value);
18921	return CreateBucketizeOptions(_fbb, ptr, _rehasher).Union();
18922	}
18923	case BuiltinOptions_GeluOptions: {
18924	auto ptr = reinterpret_cast<const tflite::GeluOptionsT *>(value);
18925	return CreateGeluOptions(_fbb, ptr, _rehasher).Union();
18926	}
18927	case BuiltinOptions_DynamicUpdateSliceOptions: {
18928	auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptionsT *>(value);
18929	return CreateDynamicUpdateSliceOptions(_fbb, ptr, _rehasher).Union();
18930	}
18931	case BuiltinOptions_UnsortedSegmentProdOptions: {
18932	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptionsT *>(value);
18933	return CreateUnsortedSegmentProdOptions(_fbb, ptr, _rehasher).Union();
18934	}
18935	case BuiltinOptions_UnsortedSegmentMaxOptions: {
18936	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptionsT *>(value);
18937	return CreateUnsortedSegmentMaxOptions(_fbb, ptr, _rehasher).Union();
18938	}
18939	case BuiltinOptions_UnsortedSegmentMinOptions: {
18940	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptionsT *>(value);
18941	return CreateUnsortedSegmentMinOptions(_fbb, ptr, _rehasher).Union();
18942	}
18943	case BuiltinOptions_UnsortedSegmentSumOptions: {
18944	auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptionsT *>(value);
18945	return CreateUnsortedSegmentSumOptions(_fbb, ptr, _rehasher).Union();
18946	}
18947	case BuiltinOptions_ATan2Options: {
18948	auto ptr = reinterpret_cast<const tflite::ATan2OptionsT *>(value);
18949	return CreateATan2Options(_fbb, ptr, _rehasher).Union();
18950	}
18951	case BuiltinOptions_SignOptions: {
18952	auto ptr = reinterpret_cast<const tflite::SignOptionsT *>(value);
18953	return CreateSignOptions(_fbb, ptr, _rehasher).Union();
18954	}
18955	default: return `0`;
18956	}
18957	}
18958
18959	inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) : type(u.type), value(nullptr) {
18960	switch (type) {
18961	case BuiltinOptions_Conv2DOptions: {
18962	value = new tflite::Conv2DOptionsT (*reinterpret_cast<tflite::Conv2DOptionsT *>(u.value));
18963	break;
18964	}
18965	case BuiltinOptions_DepthwiseConv2DOptions: {
18966	value = new tflite::DepthwiseConv2DOptionsT (*reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(u.value));
18967	break;
18968	}
18969	case BuiltinOptions_ConcatEmbeddingsOptions: {
18970	value = new tflite::ConcatEmbeddingsOptionsT (*reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(u.value));
18971	break;
18972	}
18973	case BuiltinOptions_LSHProjectionOptions: {
18974	value = new tflite::LSHProjectionOptionsT (*reinterpret_cast<tflite::LSHProjectionOptionsT *>(u.value));
18975	break;
18976	}
18977	case BuiltinOptions_Pool2DOptions: {
18978	value = new tflite::Pool2DOptionsT (*reinterpret_cast<tflite::Pool2DOptionsT *>(u.value));
18979	break;
18980	}
18981	case BuiltinOptions_SVDFOptions: {
18982	value = new tflite::SVDFOptionsT (*reinterpret_cast<tflite::SVDFOptionsT *>(u.value));
18983	break;
18984	}
18985	case BuiltinOptions_RNNOptions: {
18986	value = new tflite::RNNOptionsT (*reinterpret_cast<tflite::RNNOptionsT *>(u.value));
18987	break;
18988	}
18989	case BuiltinOptions_FullyConnectedOptions: {
18990	value = new tflite::FullyConnectedOptionsT (*reinterpret_cast<tflite::FullyConnectedOptionsT *>(u.value));
18991	break;
18992	}
18993	case BuiltinOptions_SoftmaxOptions: {
18994	value = new tflite::SoftmaxOptionsT (*reinterpret_cast<tflite::SoftmaxOptionsT *>(u.value));
18995	break;
18996	}
18997	case BuiltinOptions_ConcatenationOptions: {
18998	value = new tflite::ConcatenationOptionsT (*reinterpret_cast<tflite::ConcatenationOptionsT *>(u.value));
18999	break;
19000	}
19001	case BuiltinOptions_AddOptions: {
19002	value = new tflite::AddOptionsT (*reinterpret_cast<tflite::AddOptionsT *>(u.value));
19003	break;
19004	}
19005	case BuiltinOptions_L2NormOptions: {
19006	value = new tflite::L2NormOptionsT (*reinterpret_cast<tflite::L2NormOptionsT *>(u.value));
19007	break;
19008	}
19009	case BuiltinOptions_LocalResponseNormalizationOptions: {
19010	value = new tflite::LocalResponseNormalizationOptionsT (*reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(u.value));
19011	break;
19012	}
19013	case BuiltinOptions_LSTMOptions: {
19014	value = new tflite::LSTMOptionsT (*reinterpret_cast<tflite::LSTMOptionsT *>(u.value));
19015	break;
19016	}
19017	case BuiltinOptions_ResizeBilinearOptions: {
19018	value = new tflite::ResizeBilinearOptionsT (*reinterpret_cast<tflite::ResizeBilinearOptionsT *>(u.value));
19019	break;
19020	}
19021	case BuiltinOptions_CallOptions: {
19022	value = new tflite::CallOptionsT (*reinterpret_cast<tflite::CallOptionsT *>(u.value));
19023	break;
19024	}
19025	case BuiltinOptions_ReshapeOptions: {
19026	value = new tflite::ReshapeOptionsT (*reinterpret_cast<tflite::ReshapeOptionsT *>(u.value));
19027	break;
19028	}
19029	case BuiltinOptions_SkipGramOptions: {
19030	value = new tflite::SkipGramOptionsT (*reinterpret_cast<tflite::SkipGramOptionsT *>(u.value));
19031	break;
19032	}
19033	case BuiltinOptions_SpaceToDepthOptions: {
19034	value = new tflite::SpaceToDepthOptionsT (*reinterpret_cast<tflite::SpaceToDepthOptionsT *>(u.value));
19035	break;
19036	}
19037	case BuiltinOptions_EmbeddingLookupSparseOptions: {
19038	value = new tflite::EmbeddingLookupSparseOptionsT (*reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(u.value));
19039	break;
19040	}
19041	case BuiltinOptions_MulOptions: {
19042	value = new tflite::MulOptionsT (*reinterpret_cast<tflite::MulOptionsT *>(u.value));
19043	break;
19044	}
19045	case BuiltinOptions_PadOptions: {
19046	value = new tflite::PadOptionsT (*reinterpret_cast<tflite::PadOptionsT *>(u.value));
19047	break;
19048	}
19049	case BuiltinOptions_GatherOptions: {
19050	value = new tflite::GatherOptionsT (*reinterpret_cast<tflite::GatherOptionsT *>(u.value));
19051	break;
19052	}
19053	case BuiltinOptions_BatchToSpaceNDOptions: {
19054	value = new tflite::BatchToSpaceNDOptionsT (*reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(u.value));
19055	break;
19056	}
19057	case BuiltinOptions_SpaceToBatchNDOptions: {
19058	value = new tflite::SpaceToBatchNDOptionsT (*reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(u.value));
19059	break;
19060	}
19061	case BuiltinOptions_TransposeOptions: {
19062	value = new tflite::TransposeOptionsT (*reinterpret_cast<tflite::TransposeOptionsT *>(u.value));
19063	break;
19064	}
19065	case BuiltinOptions_ReducerOptions: {
19066	value = new tflite::ReducerOptionsT (*reinterpret_cast<tflite::ReducerOptionsT *>(u.value));
19067	break;
19068	}
19069	case BuiltinOptions_SubOptions: {
19070	value = new tflite::SubOptionsT (*reinterpret_cast<tflite::SubOptionsT *>(u.value));
19071	break;
19072	}
19073	case BuiltinOptions_DivOptions: {
19074	value = new tflite::DivOptionsT (*reinterpret_cast<tflite::DivOptionsT *>(u.value));
19075	break;
19076	}
19077	case BuiltinOptions_SqueezeOptions: {
19078	value = new tflite::SqueezeOptionsT (*reinterpret_cast<tflite::SqueezeOptionsT *>(u.value));
19079	break;
19080	}
19081	case BuiltinOptions_SequenceRNNOptions: {
19082	value = new tflite::SequenceRNNOptionsT (*reinterpret_cast<tflite::SequenceRNNOptionsT *>(u.value));
19083	break;
19084	}
19085	case BuiltinOptions_StridedSliceOptions: {
19086	value = new tflite::StridedSliceOptionsT (*reinterpret_cast<tflite::StridedSliceOptionsT *>(u.value));
19087	break;
19088	}
19089	case BuiltinOptions_ExpOptions: {
19090	value = new tflite::ExpOptionsT (*reinterpret_cast<tflite::ExpOptionsT *>(u.value));
19091	break;
19092	}
19093	case BuiltinOptions_TopKV2Options: {
19094	value = new tflite::TopKV2OptionsT (*reinterpret_cast<tflite::TopKV2OptionsT *>(u.value));
19095	break;
19096	}
19097	case BuiltinOptions_SplitOptions: {
19098	value = new tflite::SplitOptionsT (*reinterpret_cast<tflite::SplitOptionsT *>(u.value));
19099	break;
19100	}
19101	case BuiltinOptions_LogSoftmaxOptions: {
19102	value = new tflite::LogSoftmaxOptionsT (*reinterpret_cast<tflite::LogSoftmaxOptionsT *>(u.value));
19103	break;
19104	}
19105	case BuiltinOptions_CastOptions: {
19106	value = new tflite::CastOptionsT (*reinterpret_cast<tflite::CastOptionsT *>(u.value));
19107	break;
19108	}
19109	case BuiltinOptions_DequantizeOptions: {
19110	value = new tflite::DequantizeOptionsT (*reinterpret_cast<tflite::DequantizeOptionsT *>(u.value));
19111	break;
19112	}
19113	case BuiltinOptions_MaximumMinimumOptions: {
19114	value = new tflite::MaximumMinimumOptionsT (*reinterpret_cast<tflite::MaximumMinimumOptionsT *>(u.value));
19115	break;
19116	}
19117	case BuiltinOptions_ArgMaxOptions: {
19118	value = new tflite::ArgMaxOptionsT (*reinterpret_cast<tflite::ArgMaxOptionsT *>(u.value));
19119	break;
19120	}
19121	case BuiltinOptions_LessOptions: {
19122	value = new tflite::LessOptionsT (*reinterpret_cast<tflite::LessOptionsT *>(u.value));
19123	break;
19124	}
19125	case BuiltinOptions_NegOptions: {
19126	value = new tflite::NegOptionsT (*reinterpret_cast<tflite::NegOptionsT *>(u.value));
19127	break;
19128	}
19129	case BuiltinOptions_PadV2Options: {
19130	value = new tflite::PadV2OptionsT (*reinterpret_cast<tflite::PadV2OptionsT *>(u.value));
19131	break;
19132	}
19133	case BuiltinOptions_GreaterOptions: {
19134	value = new tflite::GreaterOptionsT (*reinterpret_cast<tflite::GreaterOptionsT *>(u.value));
19135	break;
19136	}
19137	case BuiltinOptions_GreaterEqualOptions: {
19138	value = new tflite::GreaterEqualOptionsT (*reinterpret_cast<tflite::GreaterEqualOptionsT *>(u.value));
19139	break;
19140	}
19141	case BuiltinOptions_LessEqualOptions: {
19142	value = new tflite::LessEqualOptionsT (*reinterpret_cast<tflite::LessEqualOptionsT *>(u.value));
19143	break;
19144	}
19145	case BuiltinOptions_SelectOptions: {
19146	value = new tflite::SelectOptionsT (*reinterpret_cast<tflite::SelectOptionsT *>(u.value));
19147	break;
19148	}
19149	case BuiltinOptions_SliceOptions: {
19150	value = new tflite::SliceOptionsT (*reinterpret_cast<tflite::SliceOptionsT *>(u.value));
19151	break;
19152	}
19153	case BuiltinOptions_TransposeConvOptions: {
19154	value = new tflite::TransposeConvOptionsT (*reinterpret_cast<tflite::TransposeConvOptionsT *>(u.value));
19155	break;
19156	}
19157	case BuiltinOptions_SparseToDenseOptions: {
19158	value = new tflite::SparseToDenseOptionsT (*reinterpret_cast<tflite::SparseToDenseOptionsT *>(u.value));
19159	break;
19160	}
19161	case BuiltinOptions_TileOptions: {
19162	value = new tflite::TileOptionsT (*reinterpret_cast<tflite::TileOptionsT *>(u.value));
19163	break;
19164	}
19165	case BuiltinOptions_ExpandDimsOptions: {
19166	value = new tflite::ExpandDimsOptionsT (*reinterpret_cast<tflite::ExpandDimsOptionsT *>(u.value));
19167	break;
19168	}
19169	case BuiltinOptions_EqualOptions: {
19170	value = new tflite::EqualOptionsT (*reinterpret_cast<tflite::EqualOptionsT *>(u.value));
19171	break;
19172	}
19173	case BuiltinOptions_NotEqualOptions: {
19174	value = new tflite::NotEqualOptionsT (*reinterpret_cast<tflite::NotEqualOptionsT *>(u.value));
19175	break;
19176	}
19177	case BuiltinOptions_ShapeOptions: {
19178	value = new tflite::ShapeOptionsT (*reinterpret_cast<tflite::ShapeOptionsT *>(u.value));
19179	break;
19180	}
19181	case BuiltinOptions_PowOptions: {
19182	value = new tflite::PowOptionsT (*reinterpret_cast<tflite::PowOptionsT *>(u.value));
19183	break;
19184	}
19185	case BuiltinOptions_ArgMinOptions: {
19186	value = new tflite::ArgMinOptionsT (*reinterpret_cast<tflite::ArgMinOptionsT *>(u.value));
19187	break;
19188	}
19189	case BuiltinOptions_FakeQuantOptions: {
19190	value = new tflite::FakeQuantOptionsT (*reinterpret_cast<tflite::FakeQuantOptionsT *>(u.value));
19191	break;
19192	}
19193	case BuiltinOptions_PackOptions: {
19194	value = new tflite::PackOptionsT (*reinterpret_cast<tflite::PackOptionsT *>(u.value));
19195	break;
19196	}
19197	case BuiltinOptions_LogicalOrOptions: {
19198	value = new tflite::LogicalOrOptionsT (*reinterpret_cast<tflite::LogicalOrOptionsT *>(u.value));
19199	break;
19200	}
19201	case BuiltinOptions_OneHotOptions: {
19202	value = new tflite::OneHotOptionsT (*reinterpret_cast<tflite::OneHotOptionsT *>(u.value));
19203	break;
19204	}
19205	case BuiltinOptions_LogicalAndOptions: {
19206	value = new tflite::LogicalAndOptionsT (*reinterpret_cast<tflite::LogicalAndOptionsT *>(u.value));
19207	break;
19208	}
19209	case BuiltinOptions_LogicalNotOptions: {
19210	value = new tflite::LogicalNotOptionsT (*reinterpret_cast<tflite::LogicalNotOptionsT *>(u.value));
19211	break;
19212	}
19213	case BuiltinOptions_UnpackOptions: {
19214	value = new tflite::UnpackOptionsT (*reinterpret_cast<tflite::UnpackOptionsT *>(u.value));
19215	break;
19216	}
19217	case BuiltinOptions_FloorDivOptions: {
19218	value = new tflite::FloorDivOptionsT (*reinterpret_cast<tflite::FloorDivOptionsT *>(u.value));
19219	break;
19220	}
19221	case BuiltinOptions_SquareOptions: {
19222	value = new tflite::SquareOptionsT (*reinterpret_cast<tflite::SquareOptionsT *>(u.value));
19223	break;
19224	}
19225	case BuiltinOptions_ZerosLikeOptions: {
19226	value = new tflite::ZerosLikeOptionsT (*reinterpret_cast<tflite::ZerosLikeOptionsT *>(u.value));
19227	break;
19228	}
19229	case BuiltinOptions_FillOptions: {
19230	value = new tflite::FillOptionsT (*reinterpret_cast<tflite::FillOptionsT *>(u.value));
19231	break;
19232	}
19233	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
19234	value = new tflite::BidirectionalSequenceLSTMOptionsT (*reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(u.value));
19235	break;
19236	}
19237	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
19238	value = new tflite::BidirectionalSequenceRNNOptionsT (*reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(u.value));
19239	break;
19240	}
19241	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
19242	value = new tflite::UnidirectionalSequenceLSTMOptionsT (*reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(u.value));
19243	break;
19244	}
19245	case BuiltinOptions_FloorModOptions: {
19246	value = new tflite::FloorModOptionsT (*reinterpret_cast<tflite::FloorModOptionsT *>(u.value));
19247	break;
19248	}
19249	case BuiltinOptions_RangeOptions: {
19250	value = new tflite::RangeOptionsT (*reinterpret_cast<tflite::RangeOptionsT *>(u.value));
19251	break;
19252	}
19253	case BuiltinOptions_ResizeNearestNeighborOptions: {
19254	value = new tflite::ResizeNearestNeighborOptionsT (*reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(u.value));
19255	break;
19256	}
19257	case BuiltinOptions_LeakyReluOptions: {
19258	value = new tflite::LeakyReluOptionsT (*reinterpret_cast<tflite::LeakyReluOptionsT *>(u.value));
19259	break;
19260	}
19261	case BuiltinOptions_SquaredDifferenceOptions: {
19262	value = new tflite::SquaredDifferenceOptionsT (*reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(u.value));
19263	break;
19264	}
19265	case BuiltinOptions_MirrorPadOptions: {
19266	value = new tflite::MirrorPadOptionsT (*reinterpret_cast<tflite::MirrorPadOptionsT *>(u.value));
19267	break;
19268	}
19269	case BuiltinOptions_AbsOptions: {
19270	value = new tflite::AbsOptionsT (*reinterpret_cast<tflite::AbsOptionsT *>(u.value));
19271	break;
19272	}
19273	case BuiltinOptions_SplitVOptions: {
19274	value = new tflite::SplitVOptionsT (*reinterpret_cast<tflite::SplitVOptionsT *>(u.value));
19275	break;
19276	}
19277	case BuiltinOptions_UniqueOptions: {
19278	value = new tflite::UniqueOptionsT (*reinterpret_cast<tflite::UniqueOptionsT *>(u.value));
19279	break;
19280	}
19281	case BuiltinOptions_ReverseV2Options: {
19282	value = new tflite::ReverseV2OptionsT (*reinterpret_cast<tflite::ReverseV2OptionsT *>(u.value));
19283	break;
19284	}
19285	case BuiltinOptions_AddNOptions: {
19286	value = new tflite::AddNOptionsT (*reinterpret_cast<tflite::AddNOptionsT *>(u.value));
19287	break;
19288	}
19289	case BuiltinOptions_GatherNdOptions: {
19290	value = new tflite::GatherNdOptionsT (*reinterpret_cast<tflite::GatherNdOptionsT *>(u.value));
19291	break;
19292	}
19293	case BuiltinOptions_CosOptions: {
19294	value = new tflite::CosOptionsT (*reinterpret_cast<tflite::CosOptionsT *>(u.value));
19295	break;
19296	}
19297	case BuiltinOptions_WhereOptions: {
19298	value = new tflite::WhereOptionsT (*reinterpret_cast<tflite::WhereOptionsT *>(u.value));
19299	break;
19300	}
19301	case BuiltinOptions_RankOptions: {
19302	value = new tflite::RankOptionsT (*reinterpret_cast<tflite::RankOptionsT *>(u.value));
19303	break;
19304	}
19305	case BuiltinOptions_ReverseSequenceOptions: {
19306	value = new tflite::ReverseSequenceOptionsT (*reinterpret_cast<tflite::ReverseSequenceOptionsT *>(u.value));
19307	break;
19308	}
19309	case BuiltinOptions_MatrixDiagOptions: {
19310	value = new tflite::MatrixDiagOptionsT (*reinterpret_cast<tflite::MatrixDiagOptionsT *>(u.value));
19311	break;
19312	}
19313	case BuiltinOptions_QuantizeOptions: {
19314	value = new tflite::QuantizeOptionsT (*reinterpret_cast<tflite::QuantizeOptionsT *>(u.value));
19315	break;
19316	}
19317	case BuiltinOptions_MatrixSetDiagOptions: {
19318	value = new tflite::MatrixSetDiagOptionsT (*reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(u.value));
19319	break;
19320	}
19321	case BuiltinOptions_HardSwishOptions: {
19322	value = new tflite::HardSwishOptionsT (*reinterpret_cast<tflite::HardSwishOptionsT *>(u.value));
19323	break;
19324	}
19325	case BuiltinOptions_IfOptions: {
19326	value = new tflite::IfOptionsT (*reinterpret_cast<tflite::IfOptionsT *>(u.value));
19327	break;
19328	}
19329	case BuiltinOptions_WhileOptions: {
19330	value = new tflite::WhileOptionsT (*reinterpret_cast<tflite::WhileOptionsT *>(u.value));
19331	break;
19332	}
19333	case BuiltinOptions_DepthToSpaceOptions: {
19334	value = new tflite::DepthToSpaceOptionsT (*reinterpret_cast<tflite::DepthToSpaceOptionsT *>(u.value));
19335	break;
19336	}
19337	case BuiltinOptions_NonMaxSuppressionV4Options: {
19338	value = new tflite::NonMaxSuppressionV4OptionsT (*reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(u.value));
19339	break;
19340	}
19341	case BuiltinOptions_NonMaxSuppressionV5Options: {
19342	value = new tflite::NonMaxSuppressionV5OptionsT (*reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(u.value));
19343	break;
19344	}
19345	case BuiltinOptions_ScatterNdOptions: {
19346	value = new tflite::ScatterNdOptionsT (*reinterpret_cast<tflite::ScatterNdOptionsT *>(u.value));
19347	break;
19348	}
19349	case BuiltinOptions_SelectV2Options: {
19350	value = new tflite::SelectV2OptionsT (*reinterpret_cast<tflite::SelectV2OptionsT *>(u.value));
19351	break;
19352	}
19353	case BuiltinOptions_DensifyOptions: {
19354	value = new tflite::DensifyOptionsT (*reinterpret_cast<tflite::DensifyOptionsT *>(u.value));
19355	break;
19356	}
19357	case BuiltinOptions_SegmentSumOptions: {
19358	value = new tflite::SegmentSumOptionsT (*reinterpret_cast<tflite::SegmentSumOptionsT *>(u.value));
19359	break;
19360	}
19361	case BuiltinOptions_BatchMatMulOptions: {
19362	value = new tflite::BatchMatMulOptionsT (*reinterpret_cast<tflite::BatchMatMulOptionsT *>(u.value));
19363	break;
19364	}
19365	case BuiltinOptions_CumsumOptions: {
19366	value = new tflite::CumsumOptionsT (*reinterpret_cast<tflite::CumsumOptionsT *>(u.value));
19367	break;
19368	}
19369	case BuiltinOptions_CallOnceOptions: {
19370	value = new tflite::CallOnceOptionsT (*reinterpret_cast<tflite::CallOnceOptionsT *>(u.value));
19371	break;
19372	}
19373	case BuiltinOptions_BroadcastToOptions: {
19374	value = new tflite::BroadcastToOptionsT (*reinterpret_cast<tflite::BroadcastToOptionsT *>(u.value));
19375	break;
19376	}
19377	case BuiltinOptions_Rfft2dOptions: {
19378	value = new tflite::Rfft2dOptionsT (*reinterpret_cast<tflite::Rfft2dOptionsT *>(u.value));
19379	break;
19380	}
19381	case BuiltinOptions_Conv3DOptions: {
19382	value = new tflite::Conv3DOptionsT (*reinterpret_cast<tflite::Conv3DOptionsT *>(u.value));
19383	break;
19384	}
19385	case BuiltinOptions_HashtableOptions: {
19386	value = new tflite::HashtableOptionsT (*reinterpret_cast<tflite::HashtableOptionsT *>(u.value));
19387	break;
19388	}
19389	case BuiltinOptions_HashtableFindOptions: {
19390	value = new tflite::HashtableFindOptionsT (*reinterpret_cast<tflite::HashtableFindOptionsT *>(u.value));
19391	break;
19392	}
19393	case BuiltinOptions_HashtableImportOptions: {
19394	value = new tflite::HashtableImportOptionsT (*reinterpret_cast<tflite::HashtableImportOptionsT *>(u.value));
19395	break;
19396	}
19397	case BuiltinOptions_HashtableSizeOptions: {
19398	value = new tflite::HashtableSizeOptionsT (*reinterpret_cast<tflite::HashtableSizeOptionsT *>(u.value));
19399	break;
19400	}
19401	case BuiltinOptions_VarHandleOptions: {
19402	value = new tflite::VarHandleOptionsT (*reinterpret_cast<tflite::VarHandleOptionsT *>(u.value));
19403	break;
19404	}
19405	case BuiltinOptions_ReadVariableOptions: {
19406	value = new tflite::ReadVariableOptionsT (*reinterpret_cast<tflite::ReadVariableOptionsT *>(u.value));
19407	break;
19408	}
19409	case BuiltinOptions_AssignVariableOptions: {
19410	value = new tflite::AssignVariableOptionsT (*reinterpret_cast<tflite::AssignVariableOptionsT *>(u.value));
19411	break;
19412	}
19413	case BuiltinOptions_RandomOptions: {
19414	value = new tflite::RandomOptionsT (*reinterpret_cast<tflite::RandomOptionsT *>(u.value));
19415	break;
19416	}
19417	case BuiltinOptions_BucketizeOptions: {
19418	value = new tflite::BucketizeOptionsT (*reinterpret_cast<tflite::BucketizeOptionsT *>(u.value));
19419	break;
19420	}
19421	case BuiltinOptions_GeluOptions: {
19422	value = new tflite::GeluOptionsT (*reinterpret_cast<tflite::GeluOptionsT *>(u.value));
19423	break;
19424	}
19425	case BuiltinOptions_DynamicUpdateSliceOptions: {
19426	value = new tflite::DynamicUpdateSliceOptionsT (*reinterpret_cast<tflite::DynamicUpdateSliceOptionsT *>(u.value));
19427	break;
19428	}
19429	case BuiltinOptions_UnsortedSegmentProdOptions: {
19430	value = new tflite::UnsortedSegmentProdOptionsT (*reinterpret_cast<tflite::UnsortedSegmentProdOptionsT *>(u.value));
19431	break;
19432	}
19433	case BuiltinOptions_UnsortedSegmentMaxOptions: {
19434	value = new tflite::UnsortedSegmentMaxOptionsT (*reinterpret_cast<tflite::UnsortedSegmentMaxOptionsT *>(u.value));
19435	break;
19436	}
19437	case BuiltinOptions_UnsortedSegmentMinOptions: {
19438	value = new tflite::UnsortedSegmentMinOptionsT (*reinterpret_cast<tflite::UnsortedSegmentMinOptionsT *>(u.value));
19439	break;
19440	}
19441	case BuiltinOptions_UnsortedSegmentSumOptions: {
19442	value = new tflite::UnsortedSegmentSumOptionsT (*reinterpret_cast<tflite::UnsortedSegmentSumOptionsT *>(u.value));
19443	break;
19444	}
19445	case BuiltinOptions_ATan2Options: {
19446	value = new tflite::ATan2OptionsT (*reinterpret_cast<tflite::ATan2OptionsT *>(u.value));
19447	break;
19448	}
19449	case BuiltinOptions_SignOptions: {
19450	value = new tflite::SignOptionsT (*reinterpret_cast<tflite::SignOptionsT *>(u.value));
19451	break;
19452	}
19453	default:
19454	break;
19455	}
19456	}
19457
19458	inline void BuiltinOptionsUnion::Reset() {
19459	switch (type) {
19460	case BuiltinOptions_Conv2DOptions: {
19461	auto ptr = reinterpret_cast<tflite::Conv2DOptionsT *>(value);
19462	delete ptr;
19463	break;
19464	}
19465	case BuiltinOptions_DepthwiseConv2DOptions: {
19466	auto ptr = reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(value);
19467	delete ptr;
19468	break;
19469	}
19470	case BuiltinOptions_ConcatEmbeddingsOptions: {
19471	auto ptr = reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(value);
19472	delete ptr;
19473	break;
19474	}
19475	case BuiltinOptions_LSHProjectionOptions: {
19476	auto ptr = reinterpret_cast<tflite::LSHProjectionOptionsT *>(value);
19477	delete ptr;
19478	break;
19479	}
19480	case BuiltinOptions_Pool2DOptions: {
19481	auto ptr = reinterpret_cast<tflite::Pool2DOptionsT *>(value);
19482	delete ptr;
19483	break;
19484	}
19485	case BuiltinOptions_SVDFOptions: {
19486	auto ptr = reinterpret_cast<tflite::SVDFOptionsT *>(value);
19487	delete ptr;
19488	break;
19489	}
19490	case BuiltinOptions_RNNOptions: {
19491	auto ptr = reinterpret_cast<tflite::RNNOptionsT *>(value);
19492	delete ptr;
19493	break;
19494	}
19495	case BuiltinOptions_FullyConnectedOptions: {
19496	auto ptr = reinterpret_cast<tflite::FullyConnectedOptionsT *>(value);
19497	delete ptr;
19498	break;
19499	}
19500	case BuiltinOptions_SoftmaxOptions: {
19501	auto ptr = reinterpret_cast<tflite::SoftmaxOptionsT *>(value);
19502	delete ptr;
19503	break;
19504	}
19505	case BuiltinOptions_ConcatenationOptions: {
19506	auto ptr = reinterpret_cast<tflite::ConcatenationOptionsT *>(value);
19507	delete ptr;
19508	break;
19509	}
19510	case BuiltinOptions_AddOptions: {
19511	auto ptr = reinterpret_cast<tflite::AddOptionsT *>(value);
19512	delete ptr;
19513	break;
19514	}
19515	case BuiltinOptions_L2NormOptions: {
19516	auto ptr = reinterpret_cast<tflite::L2NormOptionsT *>(value);
19517	delete ptr;
19518	break;
19519	}
19520	case BuiltinOptions_LocalResponseNormalizationOptions: {
19521	auto ptr = reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(value);
19522	delete ptr;
19523	break;
19524	}
19525	case BuiltinOptions_LSTMOptions: {
19526	auto ptr = reinterpret_cast<tflite::LSTMOptionsT *>(value);
19527	delete ptr;
19528	break;
19529	}
19530	case BuiltinOptions_ResizeBilinearOptions: {
19531	auto ptr = reinterpret_cast<tflite::ResizeBilinearOptionsT *>(value);
19532	delete ptr;
19533	break;
19534	}
19535	case BuiltinOptions_CallOptions: {
19536	auto ptr = reinterpret_cast<tflite::CallOptionsT *>(value);
19537	delete ptr;
19538	break;
19539	}
19540	case BuiltinOptions_ReshapeOptions: {
19541	auto ptr = reinterpret_cast<tflite::ReshapeOptionsT *>(value);
19542	delete ptr;
19543	break;
19544	}
19545	case BuiltinOptions_SkipGramOptions: {
19546	auto ptr = reinterpret_cast<tflite::SkipGramOptionsT *>(value);
19547	delete ptr;
19548	break;
19549	}
19550	case BuiltinOptions_SpaceToDepthOptions: {
19551	auto ptr = reinterpret_cast<tflite::SpaceToDepthOptionsT *>(value);
19552	delete ptr;
19553	break;
19554	}
19555	case BuiltinOptions_EmbeddingLookupSparseOptions: {
19556	auto ptr = reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(value);
19557	delete ptr;
19558	break;
19559	}
19560	case BuiltinOptions_MulOptions: {
19561	auto ptr = reinterpret_cast<tflite::MulOptionsT *>(value);
19562	delete ptr;
19563	break;
19564	}
19565	case BuiltinOptions_PadOptions: {
19566	auto ptr = reinterpret_cast<tflite::PadOptionsT *>(value);
19567	delete ptr;
19568	break;
19569	}
19570	case BuiltinOptions_GatherOptions: {
19571	auto ptr = reinterpret_cast<tflite::GatherOptionsT *>(value);
19572	delete ptr;
19573	break;
19574	}
19575	case BuiltinOptions_BatchToSpaceNDOptions: {
19576	auto ptr = reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(value);
19577	delete ptr;
19578	break;
19579	}
19580	case BuiltinOptions_SpaceToBatchNDOptions: {
19581	auto ptr = reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(value);
19582	delete ptr;
19583	break;
19584	}
19585	case BuiltinOptions_TransposeOptions: {
19586	auto ptr = reinterpret_cast<tflite::TransposeOptionsT *>(value);
19587	delete ptr;
19588	break;
19589	}
19590	case BuiltinOptions_ReducerOptions: {
19591	auto ptr = reinterpret_cast<tflite::ReducerOptionsT *>(value);
19592	delete ptr;
19593	break;
19594	}
19595	case BuiltinOptions_SubOptions: {
19596	auto ptr = reinterpret_cast<tflite::SubOptionsT *>(value);
19597	delete ptr;
19598	break;
19599	}
19600	case BuiltinOptions_DivOptions: {
19601	auto ptr = reinterpret_cast<tflite::DivOptionsT *>(value);
19602	delete ptr;
19603	break;
19604	}
19605	case BuiltinOptions_SqueezeOptions: {
19606	auto ptr = reinterpret_cast<tflite::SqueezeOptionsT *>(value);
19607	delete ptr;
19608	break;
19609	}
19610	case BuiltinOptions_SequenceRNNOptions: {
19611	auto ptr = reinterpret_cast<tflite::SequenceRNNOptionsT *>(value);
19612	delete ptr;
19613	break;
19614	}
19615	case BuiltinOptions_StridedSliceOptions: {
19616	auto ptr = reinterpret_cast<tflite::StridedSliceOptionsT *>(value);
19617	delete ptr;
19618	break;
19619	}
19620	case BuiltinOptions_ExpOptions: {
19621	auto ptr = reinterpret_cast<tflite::ExpOptionsT *>(value);
19622	delete ptr;
19623	break;
19624	}
19625	case BuiltinOptions_TopKV2Options: {
19626	auto ptr = reinterpret_cast<tflite::TopKV2OptionsT *>(value);
19627	delete ptr;
19628	break;
19629	}
19630	case BuiltinOptions_SplitOptions: {
19631	auto ptr = reinterpret_cast<tflite::SplitOptionsT *>(value);
19632	delete ptr;
19633	break;
19634	}
19635	case BuiltinOptions_LogSoftmaxOptions: {
19636	auto ptr = reinterpret_cast<tflite::LogSoftmaxOptionsT *>(value);
19637	delete ptr;
19638	break;
19639	}
19640	case BuiltinOptions_CastOptions: {
19641	auto ptr = reinterpret_cast<tflite::CastOptionsT *>(value);
19642	delete ptr;
19643	break;
19644	}
19645	case BuiltinOptions_DequantizeOptions: {
19646	auto ptr = reinterpret_cast<tflite::DequantizeOptionsT *>(value);
19647	delete ptr;
19648	break;
19649	}
19650	case BuiltinOptions_MaximumMinimumOptions: {
19651	auto ptr = reinterpret_cast<tflite::MaximumMinimumOptionsT *>(value);
19652	delete ptr;
19653	break;
19654	}
19655	case BuiltinOptions_ArgMaxOptions: {
19656	auto ptr = reinterpret_cast<tflite::ArgMaxOptionsT *>(value);
19657	delete ptr;
19658	break;
19659	}
19660	case BuiltinOptions_LessOptions: {
19661	auto ptr = reinterpret_cast<tflite::LessOptionsT *>(value);
19662	delete ptr;
19663	break;
19664	}
19665	case BuiltinOptions_NegOptions: {
19666	auto ptr = reinterpret_cast<tflite::NegOptionsT *>(value);
19667	delete ptr;
19668	break;
19669	}
19670	case BuiltinOptions_PadV2Options: {
19671	auto ptr = reinterpret_cast<tflite::PadV2OptionsT *>(value);
19672	delete ptr;
19673	break;
19674	}
19675	case BuiltinOptions_GreaterOptions: {
19676	auto ptr = reinterpret_cast<tflite::GreaterOptionsT *>(value);
19677	delete ptr;
19678	break;
19679	}
19680	case BuiltinOptions_GreaterEqualOptions: {
19681	auto ptr = reinterpret_cast<tflite::GreaterEqualOptionsT *>(value);
19682	delete ptr;
19683	break;
19684	}
19685	case BuiltinOptions_LessEqualOptions: {
19686	auto ptr = reinterpret_cast<tflite::LessEqualOptionsT *>(value);
19687	delete ptr;
19688	break;
19689	}
19690	case BuiltinOptions_SelectOptions: {
19691	auto ptr = reinterpret_cast<tflite::SelectOptionsT *>(value);
19692	delete ptr;
19693	break;
19694	}
19695	case BuiltinOptions_SliceOptions: {
19696	auto ptr = reinterpret_cast<tflite::SliceOptionsT *>(value);
19697	delete ptr;
19698	break;
19699	}
19700	case BuiltinOptions_TransposeConvOptions: {
19701	auto ptr = reinterpret_cast<tflite::TransposeConvOptionsT *>(value);
19702	delete ptr;
19703	break;
19704	}
19705	case BuiltinOptions_SparseToDenseOptions: {
19706	auto ptr = reinterpret_cast<tflite::SparseToDenseOptionsT *>(value);
19707	delete ptr;
19708	break;
19709	}
19710	case BuiltinOptions_TileOptions: {
19711	auto ptr = reinterpret_cast<tflite::TileOptionsT *>(value);
19712	delete ptr;
19713	break;
19714	}
19715	case BuiltinOptions_ExpandDimsOptions: {
19716	auto ptr = reinterpret_cast<tflite::ExpandDimsOptionsT *>(value);
19717	delete ptr;
19718	break;
19719	}
19720	case BuiltinOptions_EqualOptions: {
19721	auto ptr = reinterpret_cast<tflite::EqualOptionsT *>(value);
19722	delete ptr;
19723	break;
19724	}
19725	case BuiltinOptions_NotEqualOptions: {
19726	auto ptr = reinterpret_cast<tflite::NotEqualOptionsT *>(value);
19727	delete ptr;
19728	break;
19729	}
19730	case BuiltinOptions_ShapeOptions: {
19731	auto ptr = reinterpret_cast<tflite::ShapeOptionsT *>(value);
19732	delete ptr;
19733	break;
19734	}
19735	case BuiltinOptions_PowOptions: {
19736	auto ptr = reinterpret_cast<tflite::PowOptionsT *>(value);
19737	delete ptr;
19738	break;
19739	}
19740	case BuiltinOptions_ArgMinOptions: {
19741	auto ptr = reinterpret_cast<tflite::ArgMinOptionsT *>(value);
19742	delete ptr;
19743	break;
19744	}
19745	case BuiltinOptions_FakeQuantOptions: {
19746	auto ptr = reinterpret_cast<tflite::FakeQuantOptionsT *>(value);
19747	delete ptr;
19748	break;
19749	}
19750	case BuiltinOptions_PackOptions: {
19751	auto ptr = reinterpret_cast<tflite::PackOptionsT *>(value);
19752	delete ptr;
19753	break;
19754	}
19755	case BuiltinOptions_LogicalOrOptions: {
19756	auto ptr = reinterpret_cast<tflite::LogicalOrOptionsT *>(value);
19757	delete ptr;
19758	break;
19759	}
19760	case BuiltinOptions_OneHotOptions: {
19761	auto ptr = reinterpret_cast<tflite::OneHotOptionsT *>(value);
19762	delete ptr;
19763	break;
19764	}
19765	case BuiltinOptions_LogicalAndOptions: {
19766	auto ptr = reinterpret_cast<tflite::LogicalAndOptionsT *>(value);
19767	delete ptr;
19768	break;
19769	}
19770	case BuiltinOptions_LogicalNotOptions: {
19771	auto ptr = reinterpret_cast<tflite::LogicalNotOptionsT *>(value);
19772	delete ptr;
19773	break;
19774	}
19775	case BuiltinOptions_UnpackOptions: {
19776	auto ptr = reinterpret_cast<tflite::UnpackOptionsT *>(value);
19777	delete ptr;
19778	break;
19779	}
19780	case BuiltinOptions_FloorDivOptions: {
19781	auto ptr = reinterpret_cast<tflite::FloorDivOptionsT *>(value);
19782	delete ptr;
19783	break;
19784	}
19785	case BuiltinOptions_SquareOptions: {
19786	auto ptr = reinterpret_cast<tflite::SquareOptionsT *>(value);
19787	delete ptr;
19788	break;
19789	}
19790	case BuiltinOptions_ZerosLikeOptions: {
19791	auto ptr = reinterpret_cast<tflite::ZerosLikeOptionsT *>(value);
19792	delete ptr;
19793	break;
19794	}
19795	case BuiltinOptions_FillOptions: {
19796	auto ptr = reinterpret_cast<tflite::FillOptionsT *>(value);
19797	delete ptr;
19798	break;
19799	}
19800	case BuiltinOptions_BidirectionalSequenceLSTMOptions: {
19801	auto ptr = reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(value);
19802	delete ptr;
19803	break;
19804	}
19805	case BuiltinOptions_BidirectionalSequenceRNNOptions: {
19806	auto ptr = reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(value);
19807	delete ptr;
19808	break;
19809	}
19810	case BuiltinOptions_UnidirectionalSequenceLSTMOptions: {
19811	auto ptr = reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
19812	delete ptr;
19813	break;
19814	}
19815	case BuiltinOptions_FloorModOptions: {
19816	auto ptr = reinterpret_cast<tflite::FloorModOptionsT *>(value);
19817	delete ptr;
19818	break;
19819	}
19820	case BuiltinOptions_RangeOptions: {
19821	auto ptr = reinterpret_cast<tflite::RangeOptionsT *>(value);
19822	delete ptr;
19823	break;
19824	}
19825	case BuiltinOptions_ResizeNearestNeighborOptions: {
19826	auto ptr = reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(value);
19827	delete ptr;
19828	break;
19829	}
19830	case BuiltinOptions_LeakyReluOptions: {
19831	auto ptr = reinterpret_cast<tflite::LeakyReluOptionsT *>(value);
19832	delete ptr;
19833	break;
19834	}
19835	case BuiltinOptions_SquaredDifferenceOptions: {
19836	auto ptr = reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(value);
19837	delete ptr;
19838	break;
19839	}
19840	case BuiltinOptions_MirrorPadOptions: {
19841	auto ptr = reinterpret_cast<tflite::MirrorPadOptionsT *>(value);
19842	delete ptr;
19843	break;
19844	}
19845	case BuiltinOptions_AbsOptions: {
19846	auto ptr = reinterpret_cast<tflite::AbsOptionsT *>(value);
19847	delete ptr;
19848	break;
19849	}
19850	case BuiltinOptions_SplitVOptions: {
19851	auto ptr = reinterpret_cast<tflite::SplitVOptionsT *>(value);
19852	delete ptr;
19853	break;
19854	}
19855	case BuiltinOptions_UniqueOptions: {
19856	auto ptr = reinterpret_cast<tflite::UniqueOptionsT *>(value);
19857	delete ptr;
19858	break;
19859	}
19860	case BuiltinOptions_ReverseV2Options: {
19861	auto ptr = reinterpret_cast<tflite::ReverseV2OptionsT *>(value);
19862	delete ptr;
19863	break;
19864	}
19865	case BuiltinOptions_AddNOptions: {
19866	auto ptr = reinterpret_cast<tflite::AddNOptionsT *>(value);
19867	delete ptr;
19868	break;
19869	}
19870	case BuiltinOptions_GatherNdOptions: {
19871	auto ptr = reinterpret_cast<tflite::GatherNdOptionsT *>(value);
19872	delete ptr;
19873	break;
19874	}
19875	case BuiltinOptions_CosOptions: {
19876	auto ptr = reinterpret_cast<tflite::CosOptionsT *>(value);
19877	delete ptr;
19878	break;
19879	}
19880	case BuiltinOptions_WhereOptions: {
19881	auto ptr = reinterpret_cast<tflite::WhereOptionsT *>(value);
19882	delete ptr;
19883	break;
19884	}
19885	case BuiltinOptions_RankOptions: {
19886	auto ptr = reinterpret_cast<tflite::RankOptionsT *>(value);
19887	delete ptr;
19888	break;
19889	}
19890	case BuiltinOptions_ReverseSequenceOptions: {
19891	auto ptr = reinterpret_cast<tflite::ReverseSequenceOptionsT *>(value);
19892	delete ptr;
19893	break;
19894	}
19895	case BuiltinOptions_MatrixDiagOptions: {
19896	auto ptr = reinterpret_cast<tflite::MatrixDiagOptionsT *>(value);
19897	delete ptr;
19898	break;
19899	}
19900	case BuiltinOptions_QuantizeOptions: {
19901	auto ptr = reinterpret_cast<tflite::QuantizeOptionsT *>(value);
19902	delete ptr;
19903	break;
19904	}
19905	case BuiltinOptions_MatrixSetDiagOptions: {
19906	auto ptr = reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(value);
19907	delete ptr;
19908	break;
19909	}
19910	case BuiltinOptions_HardSwishOptions: {
19911	auto ptr = reinterpret_cast<tflite::HardSwishOptionsT *>(value);
19912	delete ptr;
19913	break;
19914	}
19915	case BuiltinOptions_IfOptions: {
19916	auto ptr = reinterpret_cast<tflite::IfOptionsT *>(value);
19917	delete ptr;
19918	break;
19919	}
19920	case BuiltinOptions_WhileOptions: {
19921	auto ptr = reinterpret_cast<tflite::WhileOptionsT *>(value);
19922	delete ptr;
19923	break;
19924	}
19925	case BuiltinOptions_DepthToSpaceOptions: {
19926	auto ptr = reinterpret_cast<tflite::DepthToSpaceOptionsT *>(value);
19927	delete ptr;
19928	break;
19929	}
19930	case BuiltinOptions_NonMaxSuppressionV4Options: {
19931	auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(value);
19932	delete ptr;
19933	break;
19934	}
19935	case BuiltinOptions_NonMaxSuppressionV5Options: {
19936	auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(value);
19937	delete ptr;
19938	break;
19939	}
19940	case BuiltinOptions_ScatterNdOptions: {
19941	auto ptr = reinterpret_cast<tflite::ScatterNdOptionsT *>(value);
19942	delete ptr;
19943	break;
19944	}
19945	case BuiltinOptions_SelectV2Options: {
19946	auto ptr = reinterpret_cast<tflite::SelectV2OptionsT *>(value);
19947	delete ptr;
19948	break;
19949	}
19950	case BuiltinOptions_DensifyOptions: {
19951	auto ptr = reinterpret_cast<tflite::DensifyOptionsT *>(value);
19952	delete ptr;
19953	break;
19954	}
19955	case BuiltinOptions_SegmentSumOptions: {
19956	auto ptr = reinterpret_cast<tflite::SegmentSumOptionsT *>(value);
19957	delete ptr;
19958	break;
19959	}
19960	case BuiltinOptions_BatchMatMulOptions: {
19961	auto ptr = reinterpret_cast<tflite::BatchMatMulOptionsT *>(value);
19962	delete ptr;
19963	break;
19964	}
19965	case BuiltinOptions_CumsumOptions: {
19966	auto ptr = reinterpret_cast<tflite::CumsumOptionsT *>(value);
19967	delete ptr;
19968	break;
19969	}
19970	case BuiltinOptions_CallOnceOptions: {
19971	auto ptr = reinterpret_cast<tflite::CallOnceOptionsT *>(value);
19972	delete ptr;
19973	break;
19974	}
19975	case BuiltinOptions_BroadcastToOptions: {
19976	auto ptr = reinterpret_cast<tflite::BroadcastToOptionsT *>(value);
19977	delete ptr;
19978	break;
19979	}
19980	case BuiltinOptions_Rfft2dOptions: {
19981	auto ptr = reinterpret_cast<tflite::Rfft2dOptionsT *>(value);
19982	delete ptr;
19983	break;
19984	}
19985	case BuiltinOptions_Conv3DOptions: {
19986	auto ptr = reinterpret_cast<tflite::Conv3DOptionsT *>(value);
19987	delete ptr;
19988	break;
19989	}
19990	case BuiltinOptions_HashtableOptions: {
19991	auto ptr = reinterpret_cast<tflite::HashtableOptionsT *>(value);
19992	delete ptr;
19993	break;
19994	}
19995	case BuiltinOptions_HashtableFindOptions: {
19996	auto ptr = reinterpret_cast<tflite::HashtableFindOptionsT *>(value);
19997	delete ptr;
19998	break;
19999	}
20000	case BuiltinOptions_HashtableImportOptions: {
20001	auto ptr = reinterpret_cast<tflite::HashtableImportOptionsT *>(value);
20002	delete ptr;
20003	break;
20004	}
20005	case BuiltinOptions_HashtableSizeOptions: {
20006	auto ptr = reinterpret_cast<tflite::HashtableSizeOptionsT *>(value);
20007	delete ptr;
20008	break;
20009	}
20010	case BuiltinOptions_VarHandleOptions: {
20011	auto ptr = reinterpret_cast<tflite::VarHandleOptionsT *>(value);
20012	delete ptr;
20013	break;
20014	}
20015	case BuiltinOptions_ReadVariableOptions: {
20016	auto ptr = reinterpret_cast<tflite::ReadVariableOptionsT *>(value);
20017	delete ptr;
20018	break;
20019	}
20020	case BuiltinOptions_AssignVariableOptions: {
20021	auto ptr = reinterpret_cast<tflite::AssignVariableOptionsT *>(value);
20022	delete ptr;
20023	break;
20024	}
20025	case BuiltinOptions_RandomOptions: {
20026	auto ptr = reinterpret_cast<tflite::RandomOptionsT *>(value);
20027	delete ptr;
20028	break;
20029	}
20030	case BuiltinOptions_BucketizeOptions: {
20031	auto ptr = reinterpret_cast<tflite::BucketizeOptionsT *>(value);
20032	delete ptr;
20033	break;
20034	}
20035	case BuiltinOptions_GeluOptions: {
20036	auto ptr = reinterpret_cast<tflite::GeluOptionsT *>(value);
20037	delete ptr;
20038	break;
20039	}
20040	case BuiltinOptions_DynamicUpdateSliceOptions: {
20041	auto ptr = reinterpret_cast<tflite::DynamicUpdateSliceOptionsT *>(value);
20042	delete ptr;
20043	break;
20044	}
20045	case BuiltinOptions_UnsortedSegmentProdOptions: {
20046	auto ptr = reinterpret_cast<tflite::UnsortedSegmentProdOptionsT *>(value);
20047	delete ptr;
20048	break;
20049	}
20050	case BuiltinOptions_UnsortedSegmentMaxOptions: {
20051	auto ptr = reinterpret_cast<tflite::UnsortedSegmentMaxOptionsT *>(value);
20052	delete ptr;
20053	break;
20054	}
20055	case BuiltinOptions_UnsortedSegmentMinOptions: {
20056	auto ptr = reinterpret_cast<tflite::UnsortedSegmentMinOptionsT *>(value);
20057	delete ptr;
20058	break;
20059	}
20060	case BuiltinOptions_UnsortedSegmentSumOptions: {
20061	auto ptr = reinterpret_cast<tflite::UnsortedSegmentSumOptionsT *>(value);
20062	delete ptr;
20063	break;
20064	}
20065	case BuiltinOptions_ATan2Options: {
20066	auto ptr = reinterpret_cast<tflite::ATan2OptionsT *>(value);
20067	delete ptr;
20068	break;
20069	}
20070	case BuiltinOptions_SignOptions: {
20071	auto ptr = reinterpret_cast<tflite::SignOptionsT *>(value);
20072	delete ptr;
20073	break;
20074	}
20075	default: break;
20076	}
20077	value = nullptr;
20078	type = BuiltinOptions_NONE;
20079	}
20080
20081	inline const tflite::Model GetModel(const* void *buf) {
20082	return flatbuffers::GetRoot<tflite::Model>(buf);
20083	}
20084
20085	inline const tflite::Model GetSizePrefixedModel(const* void *buf) {
20086	return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
20087	}
20088
20089	inline const char *ModelIdentifier() {
20090	return "TFL3";
20091	}
20092
20093	inline bool ModelBufferHasIdentifier(const void *buf) {
20094	return flatbuffers::BufferHasIdentifier(
20095	buf, ModelIdentifier());
20096	}
20097
20098	inline bool SizePrefixedModelBufferHasIdentifier(const void *buf) {
20099	return flatbuffers::BufferHasIdentifier(
20100	buf, ModelIdentifier(), true);
20101	}
20102
20103	inline bool VerifyModelBuffer(
20104	flatbuffers::Verifier &verifier) {
20105	return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
20106	}
20107
20108	inline bool VerifySizePrefixedModelBuffer(
20109	flatbuffers::Verifier &verifier) {
20110	return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
20111	}
20112
20113	inline const char *ModelExtension() {
20114	return "tflite";
20115	}
20116
20117	inline void FinishModelBuffer(
20118	flatbuffers::FlatBufferBuilder &fbb,
20119	flatbuffers::Offset<tflite::Model> root) {
20120	fbb.Finish(root, ModelIdentifier());
20121	}
20122
20123	inline void FinishSizePrefixedModelBuffer(
20124	flatbuffers::FlatBufferBuilder &fbb,
20125	flatbuffers::Offset<tflite::Model> root) {
20126	fbb.FinishSizePrefixed(root, ModelIdentifier());
20127	}
20128
20129	inline std::unique_ptr<tflite::ModelT> UnPackModel(
20130	const void *buf,
20131	const flatbuffers::resolver_function_t res = nullptr*) {
20132	return std::unique_ptr<tflite::ModelT>(GetModel(buf)->UnPack(res));
20133	}
20134
20135	inline std::unique_ptr<tflite::ModelT> UnPackSizePrefixedModel(
20136	const void *buf,
20137	const flatbuffers::resolver_function_t res = nullptr*) {
20138	return std::unique_ptr<tflite::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
20139	}
20140
20141	} // namespace tflite
20142
20143	#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
20144

Browse the source code of tensorflow/tensorflow/lite/schema/schema_generated.h