• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Copyright 2020 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_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
19 #define FLATBUFFERS_GENERATED_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
20 
21 #include "flatbuffers/flatbuffers.h"
22 
23 namespace tflite {
24 namespace gpu {
25 namespace data {
26 
27 struct Int4;
28 struct Int4Builder;
29 
30 struct Int3;
31 struct Int3Builder;
32 
33 struct Int2;
34 struct Int2Builder;
35 
36 struct StateVariable;
37 struct StateVariableBuilder;
38 
39 struct GPUObjectDescriptor;
40 struct GPUObjectDescriptorBuilder;
41 
42 struct IntValue;
43 struct IntValueBuilder;
44 
45 struct FloatValue;
46 struct FloatValueBuilder;
47 
48 struct HalfValue;
49 struct HalfValueBuilder;
50 
51 struct BufferDescriptor;
52 struct BufferDescriptorBuilder;
53 
54 struct Texture2DDescriptor;
55 struct Texture2DDescriptorBuilder;
56 
57 struct TensorLinearDescriptor;
58 struct TensorLinearDescriptorBuilder;
59 
60 struct BHWDC;
61 struct BHWDCBuilder;
62 
63 struct TensorDescriptor;
64 struct TensorDescriptorBuilder;
65 
66 struct BufferDescriptorMapValue;
67 struct BufferDescriptorMapValueBuilder;
68 
69 struct Texture2DDescriptorMapValue;
70 struct Texture2DDescriptorMapValueBuilder;
71 
72 struct TensorLinearDescriptorMapValue;
73 struct TensorLinearDescriptorMapValueBuilder;
74 
75 struct TensorDescriptorMapValue;
76 struct TensorDescriptorMapValueBuilder;
77 
78 struct Arguments;
79 struct ArgumentsBuilder;
80 
81 struct OperationDef;
82 struct OperationDefBuilder;
83 
84 struct CompilerOption;
85 struct CompilerOptionBuilder;
86 
87 struct GPUOperation;
88 struct GPUOperationBuilder;
89 
90 enum class AccessType : int8_t {
91   READ = 0,
92   WRITE = 1,
93   READ_WRITE = 2,
94   MIN = READ,
95   MAX = READ_WRITE
96 };
97 
EnumValuesAccessType()98 inline const AccessType (&EnumValuesAccessType())[3] {
99   static const AccessType values[] = {
100     AccessType::READ,
101     AccessType::WRITE,
102     AccessType::READ_WRITE
103   };
104   return values;
105 }
106 
EnumNamesAccessType()107 inline const char * const *EnumNamesAccessType() {
108   static const char * const names[4] = {
109     "READ",
110     "WRITE",
111     "READ_WRITE",
112     nullptr
113   };
114   return names;
115 }
116 
EnumNameAccessType(AccessType e)117 inline const char *EnumNameAccessType(AccessType e) {
118   if (flatbuffers::IsOutRange(e, AccessType::READ, AccessType::READ_WRITE)) return "";
119   const size_t index = static_cast<size_t>(e);
120   return EnumNamesAccessType()[index];
121 }
122 
123 enum class DataType : int8_t {
124   UNKNOWN = 0,
125   FLOAT16 = 1,
126   FLOAT32 = 2,
127   FLOAT64 = 3,
128   UINT8 = 4,
129   INT8 = 5,
130   UINT16 = 6,
131   INT16 = 7,
132   UINT32 = 8,
133   INT32 = 9,
134   UINT64 = 10,
135   INT64 = 11,
136   MIN = UNKNOWN,
137   MAX = INT64
138 };
139 
EnumValuesDataType()140 inline const DataType (&EnumValuesDataType())[12] {
141   static const DataType values[] = {
142       DataType::UNKNOWN, DataType::FLOAT16, DataType::FLOAT32,
143       DataType::FLOAT64, DataType::UINT8,   DataType::INT8,
144       DataType::UINT16,  DataType::INT16,   DataType::UINT32,
145       DataType::INT32,   DataType::UINT64,  DataType::INT64};
146   return values;
147 }
148 
EnumNamesDataType()149 inline const char * const *EnumNamesDataType() {
150   static const char *const names[13] = {
151       "UNKNOWN", "FLOAT16", "FLOAT32", "FLOAT64", "UINT8", "INT8", "UINT16",
152       "INT16",   "UINT32",  "INT32",   "UINT64",  "INT64", nullptr};
153   return names;
154 }
155 
EnumNameDataType(DataType e)156 inline const char *EnumNameDataType(DataType e) {
157   if (flatbuffers::IsOutRange(e, DataType::UNKNOWN, DataType::INT64)) return "";
158   const size_t index = static_cast<size_t>(e);
159   return EnumNamesDataType()[index];
160 }
161 
162 enum class MemoryType : int8_t {
163   GLOBAL = 0,
164   CONSTANT = 1,
165   LOCAL = 2,
166   MIN = GLOBAL,
167   MAX = LOCAL
168 };
169 
EnumValuesMemoryType()170 inline const MemoryType (&EnumValuesMemoryType())[3] {
171   static const MemoryType values[] = {
172     MemoryType::GLOBAL,
173     MemoryType::CONSTANT,
174     MemoryType::LOCAL
175   };
176   return values;
177 }
178 
EnumNamesMemoryType()179 inline const char * const *EnumNamesMemoryType() {
180   static const char * const names[4] = {
181     "GLOBAL",
182     "CONSTANT",
183     "LOCAL",
184     nullptr
185   };
186   return names;
187 }
188 
EnumNameMemoryType(MemoryType e)189 inline const char *EnumNameMemoryType(MemoryType e) {
190   if (flatbuffers::IsOutRange(e, MemoryType::GLOBAL, MemoryType::LOCAL)) return "";
191   const size_t index = static_cast<size_t>(e);
192   return EnumNamesMemoryType()[index];
193 }
194 
195 enum class LinearStorageType : int8_t {
196   BUFFER = 0,
197   TEXTURE_2D = 1,
198   MIN = BUFFER,
199   MAX = TEXTURE_2D
200 };
201 
EnumValuesLinearStorageType()202 inline const LinearStorageType (&EnumValuesLinearStorageType())[2] {
203   static const LinearStorageType values[] = {
204     LinearStorageType::BUFFER,
205     LinearStorageType::TEXTURE_2D
206   };
207   return values;
208 }
209 
EnumNamesLinearStorageType()210 inline const char * const *EnumNamesLinearStorageType() {
211   static const char * const names[3] = {
212     "BUFFER",
213     "TEXTURE_2D",
214     nullptr
215   };
216   return names;
217 }
218 
EnumNameLinearStorageType(LinearStorageType e)219 inline const char *EnumNameLinearStorageType(LinearStorageType e) {
220   if (flatbuffers::IsOutRange(e, LinearStorageType::BUFFER, LinearStorageType::TEXTURE_2D)) return "";
221   const size_t index = static_cast<size_t>(e);
222   return EnumNamesLinearStorageType()[index];
223 }
224 
225 enum class TensorStorageType : int8_t {
226   UNKNOWN = 0,
227   BUFFER = 1,
228   IMAGE_BUFFER = 2,
229   TEXTURE_2D = 3,
230   TEXTURE_3D = 4,
231   TEXTURE_ARRAY = 5,
232   SINGLE_TEXTURE_2D = 6,
233   MIN = UNKNOWN,
234   MAX = SINGLE_TEXTURE_2D
235 };
236 
EnumValuesTensorStorageType()237 inline const TensorStorageType (&EnumValuesTensorStorageType())[7] {
238   static const TensorStorageType values[] = {
239     TensorStorageType::UNKNOWN,
240     TensorStorageType::BUFFER,
241     TensorStorageType::IMAGE_BUFFER,
242     TensorStorageType::TEXTURE_2D,
243     TensorStorageType::TEXTURE_3D,
244     TensorStorageType::TEXTURE_ARRAY,
245     TensorStorageType::SINGLE_TEXTURE_2D
246   };
247   return values;
248 }
249 
EnumNamesTensorStorageType()250 inline const char * const *EnumNamesTensorStorageType() {
251   static const char * const names[8] = {
252     "UNKNOWN",
253     "BUFFER",
254     "IMAGE_BUFFER",
255     "TEXTURE_2D",
256     "TEXTURE_3D",
257     "TEXTURE_ARRAY",
258     "SINGLE_TEXTURE_2D",
259     nullptr
260   };
261   return names;
262 }
263 
EnumNameTensorStorageType(TensorStorageType e)264 inline const char *EnumNameTensorStorageType(TensorStorageType e) {
265   if (flatbuffers::IsOutRange(e, TensorStorageType::UNKNOWN, TensorStorageType::SINGLE_TEXTURE_2D)) return "";
266   const size_t index = static_cast<size_t>(e);
267   return EnumNamesTensorStorageType()[index];
268 }
269 
270 enum class Layout : int8_t {
271   UNKNOWN = 0,
272   HWC = 1,
273   BHWC = 2,
274   HWDC = 3,
275   BHWDC = 4,
276   MIN = UNKNOWN,
277   MAX = BHWDC
278 };
279 
EnumValuesLayout()280 inline const Layout (&EnumValuesLayout())[5] {
281   static const Layout values[] = {
282     Layout::UNKNOWN,
283     Layout::HWC,
284     Layout::BHWC,
285     Layout::HWDC,
286     Layout::BHWDC
287   };
288   return values;
289 }
290 
EnumNamesLayout()291 inline const char * const *EnumNamesLayout() {
292   static const char * const names[6] = {
293     "UNKNOWN",
294     "HWC",
295     "BHWC",
296     "HWDC",
297     "BHWDC",
298     nullptr
299   };
300   return names;
301 }
302 
EnumNameLayout(Layout e)303 inline const char *EnumNameLayout(Layout e) {
304   if (flatbuffers::IsOutRange(e, Layout::UNKNOWN, Layout::BHWDC)) return "";
305   const size_t index = static_cast<size_t>(e);
306   return EnumNamesLayout()[index];
307 }
308 
309 enum class CalculationsPrecision : int8_t {
310   F32 = 0,
311   F32_F16 = 1,
312   F16 = 2,
313   MIN = F32,
314   MAX = F16
315 };
316 
EnumValuesCalculationsPrecision()317 inline const CalculationsPrecision (&EnumValuesCalculationsPrecision())[3] {
318   static const CalculationsPrecision values[] = {CalculationsPrecision::F32,
319                                                  CalculationsPrecision::F32_F16,
320                                                  CalculationsPrecision::F16};
321   return values;
322 }
323 
EnumNamesCalculationsPrecision()324 inline const char *const *EnumNamesCalculationsPrecision() {
325   static const char *const names[4] = {"F32", "F32_F16", "F16", nullptr};
326   return names;
327 }
328 
EnumNameCalculationsPrecision(CalculationsPrecision e)329 inline const char *EnumNameCalculationsPrecision(CalculationsPrecision e) {
330   if (flatbuffers::IsOutRange(e, CalculationsPrecision::F32,
331                               CalculationsPrecision::F16))
332     return "";
333   const size_t index = static_cast<size_t>(e);
334   return EnumNamesCalculationsPrecision()[index];
335 }
336 
337 enum class TensorToGrid : int8_t {
338   CUSTOM = 0,
339   WB_TO_X_HD_TO_Y_S_TO_Z = 1,
340   WB_TO_X_HD_TO_Y_Z_IS_1 = 2,
341   WB_TO_X_H_TO_Y_D_TO_Z = 3,
342   B_TO_X_Y_IS_1_Z_IS_1 = 4,
343   MIN = CUSTOM,
344   MAX = B_TO_X_Y_IS_1_Z_IS_1
345 };
346 
EnumValuesTensorToGrid()347 inline const TensorToGrid (&EnumValuesTensorToGrid())[5] {
348   static const TensorToGrid values[] = {
349       TensorToGrid::CUSTOM, TensorToGrid::WB_TO_X_HD_TO_Y_S_TO_Z,
350       TensorToGrid::WB_TO_X_HD_TO_Y_Z_IS_1, TensorToGrid::WB_TO_X_H_TO_Y_D_TO_Z,
351       TensorToGrid::B_TO_X_Y_IS_1_Z_IS_1};
352   return values;
353 }
354 
EnumNamesTensorToGrid()355 inline const char *const *EnumNamesTensorToGrid() {
356   static const char *const names[6] = {"CUSTOM",
357                                        "WB_TO_X_HD_TO_Y_S_TO_Z",
358                                        "WB_TO_X_HD_TO_Y_Z_IS_1",
359                                        "WB_TO_X_H_TO_Y_D_TO_Z",
360                                        "B_TO_X_Y_IS_1_Z_IS_1",
361                                        nullptr};
362   return names;
363 }
364 
EnumNameTensorToGrid(TensorToGrid e)365 inline const char *EnumNameTensorToGrid(TensorToGrid e) {
366   if (flatbuffers::IsOutRange(e, TensorToGrid::CUSTOM,
367                               TensorToGrid::B_TO_X_Y_IS_1_Z_IS_1))
368     return "";
369   const size_t index = static_cast<size_t>(e);
370   return EnumNamesTensorToGrid()[index];
371 }
372 
373 enum class CompilerOptions : int8_t {
374   ADRENO_FULL_SIMD_LINE = 0,
375   ADRENO_MORE_WAVES = 1,
376   POWERVR_FP16 = 2,
377   CL_OPT_DISABLE = 3,
378   CL_2_0 = 4,
379   CL_3_0 = 5,
380   MIN = ADRENO_FULL_SIMD_LINE,
381   MAX = CL_3_0
382 };
383 
EnumValuesCompilerOptions()384 inline const CompilerOptions (&EnumValuesCompilerOptions())[6] {
385   static const CompilerOptions values[] = {
386       CompilerOptions::ADRENO_FULL_SIMD_LINE,
387       CompilerOptions::ADRENO_MORE_WAVES,
388       CompilerOptions::POWERVR_FP16,
389       CompilerOptions::CL_OPT_DISABLE,
390       CompilerOptions::CL_2_0,
391       CompilerOptions::CL_3_0};
392   return values;
393 }
394 
EnumNamesCompilerOptions()395 inline const char *const *EnumNamesCompilerOptions() {
396   static const char *const names[7] = {"ADRENO_FULL_SIMD_LINE",
397                                        "ADRENO_MORE_WAVES",
398                                        "POWERVR_FP16",
399                                        "CL_OPT_DISABLE",
400                                        "CL_2_0",
401                                        "CL_3_0",
402                                        nullptr};
403   return names;
404 }
405 
EnumNameCompilerOptions(CompilerOptions e)406 inline const char *EnumNameCompilerOptions(CompilerOptions e) {
407   if (flatbuffers::IsOutRange(e, CompilerOptions::ADRENO_FULL_SIMD_LINE,
408                               CompilerOptions::CL_3_0))
409     return "";
410   const size_t index = static_cast<size_t>(e);
411   return EnumNamesCompilerOptions()[index];
412 }
413 
414 struct Int4 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
415   typedef Int4Builder Builder;
416   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
417     VT_X = 4,
418     VT_Y = 6,
419     VT_Z = 8,
420     VT_W = 10
421   };
xFLATBUFFERS_FINAL_CLASS422   int32_t x() const {
423     return GetField<int32_t>(VT_X, 0);
424   }
yFLATBUFFERS_FINAL_CLASS425   int32_t y() const {
426     return GetField<int32_t>(VT_Y, 0);
427   }
zFLATBUFFERS_FINAL_CLASS428   int32_t z() const {
429     return GetField<int32_t>(VT_Z, 0);
430   }
wFLATBUFFERS_FINAL_CLASS431   int32_t w() const {
432     return GetField<int32_t>(VT_W, 0);
433   }
VerifyFLATBUFFERS_FINAL_CLASS434   bool Verify(flatbuffers::Verifier &verifier) const {
435     return VerifyTableStart(verifier) &&
436            VerifyField<int32_t>(verifier, VT_X) &&
437            VerifyField<int32_t>(verifier, VT_Y) &&
438            VerifyField<int32_t>(verifier, VT_Z) &&
439            VerifyField<int32_t>(verifier, VT_W) &&
440            verifier.EndTable();
441   }
442 };
443 
444 struct Int4Builder {
445   typedef Int4 Table;
446   flatbuffers::FlatBufferBuilder &fbb_;
447   flatbuffers::uoffset_t start_;
add_xInt4Builder448   void add_x(int32_t x) {
449     fbb_.AddElement<int32_t>(Int4::VT_X, x, 0);
450   }
add_yInt4Builder451   void add_y(int32_t y) {
452     fbb_.AddElement<int32_t>(Int4::VT_Y, y, 0);
453   }
add_zInt4Builder454   void add_z(int32_t z) {
455     fbb_.AddElement<int32_t>(Int4::VT_Z, z, 0);
456   }
add_wInt4Builder457   void add_w(int32_t w) {
458     fbb_.AddElement<int32_t>(Int4::VT_W, w, 0);
459   }
Int4BuilderInt4Builder460   explicit Int4Builder(flatbuffers::FlatBufferBuilder &_fbb)
461         : fbb_(_fbb) {
462     start_ = fbb_.StartTable();
463   }
FinishInt4Builder464   flatbuffers::Offset<Int4> Finish() {
465     const auto end = fbb_.EndTable(start_);
466     auto o = flatbuffers::Offset<Int4>(end);
467     return o;
468   }
469 };
470 
471 inline flatbuffers::Offset<Int4> CreateInt4(
472     flatbuffers::FlatBufferBuilder &_fbb,
473     int32_t x = 0,
474     int32_t y = 0,
475     int32_t z = 0,
476     int32_t w = 0) {
477   Int4Builder builder_(_fbb);
478   builder_.add_w(w);
479   builder_.add_z(z);
480   builder_.add_y(y);
481   builder_.add_x(x);
482   return builder_.Finish();
483 }
484 
485 struct Int3 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
486   typedef Int3Builder Builder;
487   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
488     VT_X = 4,
489     VT_Y = 6,
490     VT_Z = 8
491   };
xFLATBUFFERS_FINAL_CLASS492   int32_t x() const {
493     return GetField<int32_t>(VT_X, 0);
494   }
yFLATBUFFERS_FINAL_CLASS495   int32_t y() const {
496     return GetField<int32_t>(VT_Y, 0);
497   }
zFLATBUFFERS_FINAL_CLASS498   int32_t z() const {
499     return GetField<int32_t>(VT_Z, 0);
500   }
VerifyFLATBUFFERS_FINAL_CLASS501   bool Verify(flatbuffers::Verifier &verifier) const {
502     return VerifyTableStart(verifier) &&
503            VerifyField<int32_t>(verifier, VT_X) &&
504            VerifyField<int32_t>(verifier, VT_Y) &&
505            VerifyField<int32_t>(verifier, VT_Z) &&
506            verifier.EndTable();
507   }
508 };
509 
510 struct Int3Builder {
511   typedef Int3 Table;
512   flatbuffers::FlatBufferBuilder &fbb_;
513   flatbuffers::uoffset_t start_;
add_xInt3Builder514   void add_x(int32_t x) {
515     fbb_.AddElement<int32_t>(Int3::VT_X, x, 0);
516   }
add_yInt3Builder517   void add_y(int32_t y) {
518     fbb_.AddElement<int32_t>(Int3::VT_Y, y, 0);
519   }
add_zInt3Builder520   void add_z(int32_t z) {
521     fbb_.AddElement<int32_t>(Int3::VT_Z, z, 0);
522   }
Int3BuilderInt3Builder523   explicit Int3Builder(flatbuffers::FlatBufferBuilder &_fbb)
524         : fbb_(_fbb) {
525     start_ = fbb_.StartTable();
526   }
FinishInt3Builder527   flatbuffers::Offset<Int3> Finish() {
528     const auto end = fbb_.EndTable(start_);
529     auto o = flatbuffers::Offset<Int3>(end);
530     return o;
531   }
532 };
533 
534 inline flatbuffers::Offset<Int3> CreateInt3(
535     flatbuffers::FlatBufferBuilder &_fbb,
536     int32_t x = 0,
537     int32_t y = 0,
538     int32_t z = 0) {
539   Int3Builder builder_(_fbb);
540   builder_.add_z(z);
541   builder_.add_y(y);
542   builder_.add_x(x);
543   return builder_.Finish();
544 }
545 
546 struct Int2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
547   typedef Int2Builder Builder;
548   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
549     VT_X = 4,
550     VT_Y = 6
551   };
xFLATBUFFERS_FINAL_CLASS552   int32_t x() const {
553     return GetField<int32_t>(VT_X, 0);
554   }
yFLATBUFFERS_FINAL_CLASS555   int32_t y() const {
556     return GetField<int32_t>(VT_Y, 0);
557   }
VerifyFLATBUFFERS_FINAL_CLASS558   bool Verify(flatbuffers::Verifier &verifier) const {
559     return VerifyTableStart(verifier) &&
560            VerifyField<int32_t>(verifier, VT_X) &&
561            VerifyField<int32_t>(verifier, VT_Y) &&
562            verifier.EndTable();
563   }
564 };
565 
566 struct Int2Builder {
567   typedef Int2 Table;
568   flatbuffers::FlatBufferBuilder &fbb_;
569   flatbuffers::uoffset_t start_;
add_xInt2Builder570   void add_x(int32_t x) {
571     fbb_.AddElement<int32_t>(Int2::VT_X, x, 0);
572   }
add_yInt2Builder573   void add_y(int32_t y) {
574     fbb_.AddElement<int32_t>(Int2::VT_Y, y, 0);
575   }
Int2BuilderInt2Builder576   explicit Int2Builder(flatbuffers::FlatBufferBuilder &_fbb)
577         : fbb_(_fbb) {
578     start_ = fbb_.StartTable();
579   }
FinishInt2Builder580   flatbuffers::Offset<Int2> Finish() {
581     const auto end = fbb_.EndTable(start_);
582     auto o = flatbuffers::Offset<Int2>(end);
583     return o;
584   }
585 };
586 
587 inline flatbuffers::Offset<Int2> CreateInt2(
588     flatbuffers::FlatBufferBuilder &_fbb,
589     int32_t x = 0,
590     int32_t y = 0) {
591   Int2Builder builder_(_fbb);
592   builder_.add_y(y);
593   builder_.add_x(x);
594   return builder_.Finish();
595 }
596 
597 struct StateVariable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
598   typedef StateVariableBuilder Builder;
599   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
600     VT_KEY = 4,
601     VT_VALUE = 6
602   };
keyFLATBUFFERS_FINAL_CLASS603   const flatbuffers::String *key() const {
604     return GetPointer<const flatbuffers::String *>(VT_KEY);
605   }
valueFLATBUFFERS_FINAL_CLASS606   const flatbuffers::String *value() const {
607     return GetPointer<const flatbuffers::String *>(VT_VALUE);
608   }
VerifyFLATBUFFERS_FINAL_CLASS609   bool Verify(flatbuffers::Verifier &verifier) const {
610     return VerifyTableStart(verifier) &&
611            VerifyOffset(verifier, VT_KEY) &&
612            verifier.VerifyString(key()) &&
613            VerifyOffset(verifier, VT_VALUE) &&
614            verifier.VerifyString(value()) &&
615            verifier.EndTable();
616   }
617 };
618 
619 struct StateVariableBuilder {
620   typedef StateVariable Table;
621   flatbuffers::FlatBufferBuilder &fbb_;
622   flatbuffers::uoffset_t start_;
add_keyStateVariableBuilder623   void add_key(flatbuffers::Offset<flatbuffers::String> key) {
624     fbb_.AddOffset(StateVariable::VT_KEY, key);
625   }
add_valueStateVariableBuilder626   void add_value(flatbuffers::Offset<flatbuffers::String> value) {
627     fbb_.AddOffset(StateVariable::VT_VALUE, value);
628   }
StateVariableBuilderStateVariableBuilder629   explicit StateVariableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
630         : fbb_(_fbb) {
631     start_ = fbb_.StartTable();
632   }
FinishStateVariableBuilder633   flatbuffers::Offset<StateVariable> Finish() {
634     const auto end = fbb_.EndTable(start_);
635     auto o = flatbuffers::Offset<StateVariable>(end);
636     return o;
637   }
638 };
639 
640 inline flatbuffers::Offset<StateVariable> CreateStateVariable(
641     flatbuffers::FlatBufferBuilder &_fbb,
642     flatbuffers::Offset<flatbuffers::String> key = 0,
643     flatbuffers::Offset<flatbuffers::String> value = 0) {
644   StateVariableBuilder builder_(_fbb);
645   builder_.add_value(value);
646   builder_.add_key(key);
647   return builder_.Finish();
648 }
649 
650 inline flatbuffers::Offset<StateVariable> CreateStateVariableDirect(
651     flatbuffers::FlatBufferBuilder &_fbb,
652     const char *key = nullptr,
653     const char *value = nullptr) {
654   auto key__ = key ? _fbb.CreateString(key) : 0;
655   auto value__ = value ? _fbb.CreateString(value) : 0;
656   return tflite::gpu::data::CreateStateVariable(
657       _fbb,
658       key__,
659       value__);
660 }
661 
662 struct GPUObjectDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
663   typedef GPUObjectDescriptorBuilder Builder;
664   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
665     VT_STATE_VARS = 4,
666     VT_ACCESS_TYPE = 6
667   };
state_varsFLATBUFFERS_FINAL_CLASS668   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *state_vars() const {
669     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *>(VT_STATE_VARS);
670   }
access_typeFLATBUFFERS_FINAL_CLASS671   tflite::gpu::data::AccessType access_type() const {
672     return static_cast<tflite::gpu::data::AccessType>(GetField<int8_t>(VT_ACCESS_TYPE, 0));
673   }
VerifyFLATBUFFERS_FINAL_CLASS674   bool Verify(flatbuffers::Verifier &verifier) const {
675     return VerifyTableStart(verifier) &&
676            VerifyOffset(verifier, VT_STATE_VARS) &&
677            verifier.VerifyVector(state_vars()) &&
678            verifier.VerifyVectorOfTables(state_vars()) &&
679            VerifyField<int8_t>(verifier, VT_ACCESS_TYPE) &&
680            verifier.EndTable();
681   }
682 };
683 
684 struct GPUObjectDescriptorBuilder {
685   typedef GPUObjectDescriptor Table;
686   flatbuffers::FlatBufferBuilder &fbb_;
687   flatbuffers::uoffset_t start_;
add_state_varsGPUObjectDescriptorBuilder688   void add_state_vars(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>> state_vars) {
689     fbb_.AddOffset(GPUObjectDescriptor::VT_STATE_VARS, state_vars);
690   }
add_access_typeGPUObjectDescriptorBuilder691   void add_access_type(tflite::gpu::data::AccessType access_type) {
692     fbb_.AddElement<int8_t>(GPUObjectDescriptor::VT_ACCESS_TYPE, static_cast<int8_t>(access_type), 0);
693   }
GPUObjectDescriptorBuilderGPUObjectDescriptorBuilder694   explicit GPUObjectDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
695         : fbb_(_fbb) {
696     start_ = fbb_.StartTable();
697   }
FinishGPUObjectDescriptorBuilder698   flatbuffers::Offset<GPUObjectDescriptor> Finish() {
699     const auto end = fbb_.EndTable(start_);
700     auto o = flatbuffers::Offset<GPUObjectDescriptor>(end);
701     return o;
702   }
703 };
704 
705 inline flatbuffers::Offset<GPUObjectDescriptor> CreateGPUObjectDescriptor(
706     flatbuffers::FlatBufferBuilder &_fbb,
707     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>> state_vars = 0,
708     tflite::gpu::data::AccessType access_type = tflite::gpu::data::AccessType::READ) {
709   GPUObjectDescriptorBuilder builder_(_fbb);
710   builder_.add_state_vars(state_vars);
711   builder_.add_access_type(access_type);
712   return builder_.Finish();
713 }
714 
715 inline flatbuffers::Offset<GPUObjectDescriptor> CreateGPUObjectDescriptorDirect(
716     flatbuffers::FlatBufferBuilder &_fbb,
717     const std::vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *state_vars = nullptr,
718     tflite::gpu::data::AccessType access_type = tflite::gpu::data::AccessType::READ) {
719   auto state_vars__ = state_vars ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>(*state_vars) : 0;
720   return tflite::gpu::data::CreateGPUObjectDescriptor(
721       _fbb,
722       state_vars__,
723       access_type);
724 }
725 
726 struct IntValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
727   typedef IntValueBuilder Builder;
728   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
729     VT_NAME = 4,
730     VT_VALUE = 6,
731     VT_ACTIVE = 8
732   };
nameFLATBUFFERS_FINAL_CLASS733   const flatbuffers::String *name() const {
734     return GetPointer<const flatbuffers::String *>(VT_NAME);
735   }
valueFLATBUFFERS_FINAL_CLASS736   int32_t value() const {
737     return GetField<int32_t>(VT_VALUE, 0);
738   }
activeFLATBUFFERS_FINAL_CLASS739   bool active() const {
740     return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
741   }
VerifyFLATBUFFERS_FINAL_CLASS742   bool Verify(flatbuffers::Verifier &verifier) const {
743     return VerifyTableStart(verifier) &&
744            VerifyOffset(verifier, VT_NAME) &&
745            verifier.VerifyString(name()) &&
746            VerifyField<int32_t>(verifier, VT_VALUE) &&
747            VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
748            verifier.EndTable();
749   }
750 };
751 
752 struct IntValueBuilder {
753   typedef IntValue Table;
754   flatbuffers::FlatBufferBuilder &fbb_;
755   flatbuffers::uoffset_t start_;
add_nameIntValueBuilder756   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
757     fbb_.AddOffset(IntValue::VT_NAME, name);
758   }
add_valueIntValueBuilder759   void add_value(int32_t value) {
760     fbb_.AddElement<int32_t>(IntValue::VT_VALUE, value, 0);
761   }
add_activeIntValueBuilder762   void add_active(bool active) {
763     fbb_.AddElement<uint8_t>(IntValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
764   }
IntValueBuilderIntValueBuilder765   explicit IntValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
766         : fbb_(_fbb) {
767     start_ = fbb_.StartTable();
768   }
FinishIntValueBuilder769   flatbuffers::Offset<IntValue> Finish() {
770     const auto end = fbb_.EndTable(start_);
771     auto o = flatbuffers::Offset<IntValue>(end);
772     return o;
773   }
774 };
775 
776 inline flatbuffers::Offset<IntValue> CreateIntValue(
777     flatbuffers::FlatBufferBuilder &_fbb,
778     flatbuffers::Offset<flatbuffers::String> name = 0,
779     int32_t value = 0,
780     bool active = false) {
781   IntValueBuilder builder_(_fbb);
782   builder_.add_value(value);
783   builder_.add_name(name);
784   builder_.add_active(active);
785   return builder_.Finish();
786 }
787 
788 inline flatbuffers::Offset<IntValue> CreateIntValueDirect(
789     flatbuffers::FlatBufferBuilder &_fbb,
790     const char *name = nullptr,
791     int32_t value = 0,
792     bool active = false) {
793   auto name__ = name ? _fbb.CreateString(name) : 0;
794   return tflite::gpu::data::CreateIntValue(
795       _fbb,
796       name__,
797       value,
798       active);
799 }
800 
801 struct FloatValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
802   typedef FloatValueBuilder Builder;
803   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
804     VT_NAME = 4,
805     VT_VALUE = 6,
806     VT_ACTIVE = 8
807   };
nameFLATBUFFERS_FINAL_CLASS808   const flatbuffers::String *name() const {
809     return GetPointer<const flatbuffers::String *>(VT_NAME);
810   }
valueFLATBUFFERS_FINAL_CLASS811   float value() const {
812     return GetField<float>(VT_VALUE, 0.0f);
813   }
activeFLATBUFFERS_FINAL_CLASS814   bool active() const {
815     return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
816   }
VerifyFLATBUFFERS_FINAL_CLASS817   bool Verify(flatbuffers::Verifier &verifier) const {
818     return VerifyTableStart(verifier) &&
819            VerifyOffset(verifier, VT_NAME) &&
820            verifier.VerifyString(name()) &&
821            VerifyField<float>(verifier, VT_VALUE) &&
822            VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
823            verifier.EndTable();
824   }
825 };
826 
827 struct FloatValueBuilder {
828   typedef FloatValue Table;
829   flatbuffers::FlatBufferBuilder &fbb_;
830   flatbuffers::uoffset_t start_;
add_nameFloatValueBuilder831   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
832     fbb_.AddOffset(FloatValue::VT_NAME, name);
833   }
add_valueFloatValueBuilder834   void add_value(float value) {
835     fbb_.AddElement<float>(FloatValue::VT_VALUE, value, 0.0f);
836   }
add_activeFloatValueBuilder837   void add_active(bool active) {
838     fbb_.AddElement<uint8_t>(FloatValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
839   }
FloatValueBuilderFloatValueBuilder840   explicit FloatValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
841         : fbb_(_fbb) {
842     start_ = fbb_.StartTable();
843   }
FinishFloatValueBuilder844   flatbuffers::Offset<FloatValue> Finish() {
845     const auto end = fbb_.EndTable(start_);
846     auto o = flatbuffers::Offset<FloatValue>(end);
847     return o;
848   }
849 };
850 
851 inline flatbuffers::Offset<FloatValue> CreateFloatValue(
852     flatbuffers::FlatBufferBuilder &_fbb,
853     flatbuffers::Offset<flatbuffers::String> name = 0,
854     float value = 0.0f,
855     bool active = false) {
856   FloatValueBuilder builder_(_fbb);
857   builder_.add_value(value);
858   builder_.add_name(name);
859   builder_.add_active(active);
860   return builder_.Finish();
861 }
862 
863 inline flatbuffers::Offset<FloatValue> CreateFloatValueDirect(
864     flatbuffers::FlatBufferBuilder &_fbb,
865     const char *name = nullptr,
866     float value = 0.0f,
867     bool active = false) {
868   auto name__ = name ? _fbb.CreateString(name) : 0;
869   return tflite::gpu::data::CreateFloatValue(
870       _fbb,
871       name__,
872       value,
873       active);
874 }
875 
876 struct HalfValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
877   typedef HalfValueBuilder Builder;
878   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
879     VT_NAME = 4,
880     VT_VALUE = 6,
881     VT_ACTIVE = 8
882   };
nameFLATBUFFERS_FINAL_CLASS883   const flatbuffers::String *name() const {
884     return GetPointer<const flatbuffers::String *>(VT_NAME);
885   }
valueFLATBUFFERS_FINAL_CLASS886   float value() const {
887     return GetField<float>(VT_VALUE, 0.0f);
888   }
activeFLATBUFFERS_FINAL_CLASS889   bool active() const {
890     return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
891   }
VerifyFLATBUFFERS_FINAL_CLASS892   bool Verify(flatbuffers::Verifier &verifier) const {
893     return VerifyTableStart(verifier) &&
894            VerifyOffset(verifier, VT_NAME) &&
895            verifier.VerifyString(name()) &&
896            VerifyField<float>(verifier, VT_VALUE) &&
897            VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
898            verifier.EndTable();
899   }
900 };
901 
902 struct HalfValueBuilder {
903   typedef HalfValue Table;
904   flatbuffers::FlatBufferBuilder &fbb_;
905   flatbuffers::uoffset_t start_;
add_nameHalfValueBuilder906   void add_name(flatbuffers::Offset<flatbuffers::String> name) {
907     fbb_.AddOffset(HalfValue::VT_NAME, name);
908   }
add_valueHalfValueBuilder909   void add_value(float value) {
910     fbb_.AddElement<float>(HalfValue::VT_VALUE, value, 0.0f);
911   }
add_activeHalfValueBuilder912   void add_active(bool active) {
913     fbb_.AddElement<uint8_t>(HalfValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
914   }
HalfValueBuilderHalfValueBuilder915   explicit HalfValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
916         : fbb_(_fbb) {
917     start_ = fbb_.StartTable();
918   }
FinishHalfValueBuilder919   flatbuffers::Offset<HalfValue> Finish() {
920     const auto end = fbb_.EndTable(start_);
921     auto o = flatbuffers::Offset<HalfValue>(end);
922     return o;
923   }
924 };
925 
926 inline flatbuffers::Offset<HalfValue> CreateHalfValue(
927     flatbuffers::FlatBufferBuilder &_fbb,
928     flatbuffers::Offset<flatbuffers::String> name = 0,
929     float value = 0.0f,
930     bool active = false) {
931   HalfValueBuilder builder_(_fbb);
932   builder_.add_value(value);
933   builder_.add_name(name);
934   builder_.add_active(active);
935   return builder_.Finish();
936 }
937 
938 inline flatbuffers::Offset<HalfValue> CreateHalfValueDirect(
939     flatbuffers::FlatBufferBuilder &_fbb,
940     const char *name = nullptr,
941     float value = 0.0f,
942     bool active = false) {
943   auto name__ = name ? _fbb.CreateString(name) : 0;
944   return tflite::gpu::data::CreateHalfValue(
945       _fbb,
946       name__,
947       value,
948       active);
949 }
950 
951 struct BufferDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
952   typedef BufferDescriptorBuilder Builder;
953   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
954     VT_BASE_OBJ = 4,
955     VT_ELEMENT_TYPE = 6,
956     VT_ELEMENT_SIZE = 8,
957     VT_MEMORY_TYPE = 10,
958     VT_ATTRIBUTES = 12,
959     VT_SIZE = 14,
960     VT_DATA = 16
961   };
base_objFLATBUFFERS_FINAL_CLASS962   const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
963     return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
964   }
element_typeFLATBUFFERS_FINAL_CLASS965   tflite::gpu::data::DataType element_type() const {
966     return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
967   }
element_sizeFLATBUFFERS_FINAL_CLASS968   int32_t element_size() const {
969     return GetField<int32_t>(VT_ELEMENT_SIZE, 0);
970   }
memory_typeFLATBUFFERS_FINAL_CLASS971   tflite::gpu::data::MemoryType memory_type() const {
972     return static_cast<tflite::gpu::data::MemoryType>(GetField<int8_t>(VT_MEMORY_TYPE, 0));
973   }
attributesFLATBUFFERS_FINAL_CLASS974   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *attributes() const {
975     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_ATTRIBUTES);
976   }
sizeFLATBUFFERS_FINAL_CLASS977   int32_t size() const {
978     return GetField<int32_t>(VT_SIZE, 0);
979   }
dataFLATBUFFERS_FINAL_CLASS980   const flatbuffers::Vector<uint8_t> *data() const {
981     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
982   }
VerifyFLATBUFFERS_FINAL_CLASS983   bool Verify(flatbuffers::Verifier &verifier) const {
984     return VerifyTableStart(verifier) &&
985            VerifyOffset(verifier, VT_BASE_OBJ) &&
986            verifier.VerifyTable(base_obj()) &&
987            VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
988            VerifyField<int32_t>(verifier, VT_ELEMENT_SIZE) &&
989            VerifyField<int8_t>(verifier, VT_MEMORY_TYPE) &&
990            VerifyOffset(verifier, VT_ATTRIBUTES) &&
991            verifier.VerifyVector(attributes()) &&
992            verifier.VerifyVectorOfStrings(attributes()) &&
993            VerifyField<int32_t>(verifier, VT_SIZE) &&
994            VerifyOffset(verifier, VT_DATA) &&
995            verifier.VerifyVector(data()) &&
996            verifier.EndTable();
997   }
998 };
999 
1000 struct BufferDescriptorBuilder {
1001   typedef BufferDescriptor Table;
1002   flatbuffers::FlatBufferBuilder &fbb_;
1003   flatbuffers::uoffset_t start_;
add_base_objBufferDescriptorBuilder1004   void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1005     fbb_.AddOffset(BufferDescriptor::VT_BASE_OBJ, base_obj);
1006   }
add_element_typeBufferDescriptorBuilder1007   void add_element_type(tflite::gpu::data::DataType element_type) {
1008     fbb_.AddElement<int8_t>(BufferDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1009   }
add_element_sizeBufferDescriptorBuilder1010   void add_element_size(int32_t element_size) {
1011     fbb_.AddElement<int32_t>(BufferDescriptor::VT_ELEMENT_SIZE, element_size, 0);
1012   }
add_memory_typeBufferDescriptorBuilder1013   void add_memory_type(tflite::gpu::data::MemoryType memory_type) {
1014     fbb_.AddElement<int8_t>(BufferDescriptor::VT_MEMORY_TYPE, static_cast<int8_t>(memory_type), 0);
1015   }
add_attributesBufferDescriptorBuilder1016   void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> attributes) {
1017     fbb_.AddOffset(BufferDescriptor::VT_ATTRIBUTES, attributes);
1018   }
add_sizeBufferDescriptorBuilder1019   void add_size(int32_t size) {
1020     fbb_.AddElement<int32_t>(BufferDescriptor::VT_SIZE, size, 0);
1021   }
add_dataBufferDescriptorBuilder1022   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1023     fbb_.AddOffset(BufferDescriptor::VT_DATA, data);
1024   }
BufferDescriptorBuilderBufferDescriptorBuilder1025   explicit BufferDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1026         : fbb_(_fbb) {
1027     start_ = fbb_.StartTable();
1028   }
FinishBufferDescriptorBuilder1029   flatbuffers::Offset<BufferDescriptor> Finish() {
1030     const auto end = fbb_.EndTable(start_);
1031     auto o = flatbuffers::Offset<BufferDescriptor>(end);
1032     return o;
1033   }
1034 };
1035 
1036 inline flatbuffers::Offset<BufferDescriptor> CreateBufferDescriptor(
1037     flatbuffers::FlatBufferBuilder &_fbb,
1038     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1039     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1040     int32_t element_size = 0,
1041     tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1042     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> attributes = 0,
1043     int32_t size = 0,
1044     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1045   BufferDescriptorBuilder builder_(_fbb);
1046   builder_.add_data(data);
1047   builder_.add_size(size);
1048   builder_.add_attributes(attributes);
1049   builder_.add_element_size(element_size);
1050   builder_.add_base_obj(base_obj);
1051   builder_.add_memory_type(memory_type);
1052   builder_.add_element_type(element_type);
1053   return builder_.Finish();
1054 }
1055 
1056 inline flatbuffers::Offset<BufferDescriptor> CreateBufferDescriptorDirect(
1057     flatbuffers::FlatBufferBuilder &_fbb,
1058     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1059     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1060     int32_t element_size = 0,
1061     tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1062     const std::vector<flatbuffers::Offset<flatbuffers::String>> *attributes = nullptr,
1063     int32_t size = 0,
1064     const std::vector<uint8_t> *data = nullptr) {
1065   auto attributes__ = attributes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*attributes) : 0;
1066   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1067   return tflite::gpu::data::CreateBufferDescriptor(
1068       _fbb,
1069       base_obj,
1070       element_type,
1071       element_size,
1072       memory_type,
1073       attributes__,
1074       size,
1075       data__);
1076 }
1077 
1078 struct Texture2DDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1079   typedef Texture2DDescriptorBuilder Builder;
1080   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1081     VT_BASE_OBJ = 4,
1082     VT_ELEMENT_TYPE = 6,
1083     VT_NORMALIZED = 8,
1084     VT_NORMALIZED_TYPE = 10,
1085     VT_SIZE = 12,
1086     VT_DATA = 14
1087   };
base_objFLATBUFFERS_FINAL_CLASS1088   const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1089     return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1090   }
element_typeFLATBUFFERS_FINAL_CLASS1091   tflite::gpu::data::DataType element_type() const {
1092     return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
1093   }
normalizedFLATBUFFERS_FINAL_CLASS1094   bool normalized() const {
1095     return GetField<uint8_t>(VT_NORMALIZED, 0) != 0;
1096   }
normalized_typeFLATBUFFERS_FINAL_CLASS1097   tflite::gpu::data::DataType normalized_type() const {
1098     return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_NORMALIZED_TYPE, 0));
1099   }
sizeFLATBUFFERS_FINAL_CLASS1100   const tflite::gpu::data::Int2 *size() const {
1101     return GetPointer<const tflite::gpu::data::Int2 *>(VT_SIZE);
1102   }
dataFLATBUFFERS_FINAL_CLASS1103   const flatbuffers::Vector<uint8_t> *data() const {
1104     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1105   }
VerifyFLATBUFFERS_FINAL_CLASS1106   bool Verify(flatbuffers::Verifier &verifier) const {
1107     return VerifyTableStart(verifier) &&
1108            VerifyOffset(verifier, VT_BASE_OBJ) &&
1109            verifier.VerifyTable(base_obj()) &&
1110            VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
1111            VerifyField<uint8_t>(verifier, VT_NORMALIZED) &&
1112            VerifyField<int8_t>(verifier, VT_NORMALIZED_TYPE) &&
1113            VerifyOffset(verifier, VT_SIZE) &&
1114            verifier.VerifyTable(size()) &&
1115            VerifyOffset(verifier, VT_DATA) &&
1116            verifier.VerifyVector(data()) &&
1117            verifier.EndTable();
1118   }
1119 };
1120 
1121 struct Texture2DDescriptorBuilder {
1122   typedef Texture2DDescriptor Table;
1123   flatbuffers::FlatBufferBuilder &fbb_;
1124   flatbuffers::uoffset_t start_;
add_base_objTexture2DDescriptorBuilder1125   void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1126     fbb_.AddOffset(Texture2DDescriptor::VT_BASE_OBJ, base_obj);
1127   }
add_element_typeTexture2DDescriptorBuilder1128   void add_element_type(tflite::gpu::data::DataType element_type) {
1129     fbb_.AddElement<int8_t>(Texture2DDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1130   }
add_normalizedTexture2DDescriptorBuilder1131   void add_normalized(bool normalized) {
1132     fbb_.AddElement<uint8_t>(Texture2DDescriptor::VT_NORMALIZED, static_cast<uint8_t>(normalized), 0);
1133   }
add_normalized_typeTexture2DDescriptorBuilder1134   void add_normalized_type(tflite::gpu::data::DataType normalized_type) {
1135     fbb_.AddElement<int8_t>(Texture2DDescriptor::VT_NORMALIZED_TYPE, static_cast<int8_t>(normalized_type), 0);
1136   }
add_sizeTexture2DDescriptorBuilder1137   void add_size(flatbuffers::Offset<tflite::gpu::data::Int2> size) {
1138     fbb_.AddOffset(Texture2DDescriptor::VT_SIZE, size);
1139   }
add_dataTexture2DDescriptorBuilder1140   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1141     fbb_.AddOffset(Texture2DDescriptor::VT_DATA, data);
1142   }
Texture2DDescriptorBuilderTexture2DDescriptorBuilder1143   explicit Texture2DDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1144         : fbb_(_fbb) {
1145     start_ = fbb_.StartTable();
1146   }
FinishTexture2DDescriptorBuilder1147   flatbuffers::Offset<Texture2DDescriptor> Finish() {
1148     const auto end = fbb_.EndTable(start_);
1149     auto o = flatbuffers::Offset<Texture2DDescriptor>(end);
1150     return o;
1151   }
1152 };
1153 
1154 inline flatbuffers::Offset<Texture2DDescriptor> CreateTexture2DDescriptor(
1155     flatbuffers::FlatBufferBuilder &_fbb,
1156     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1157     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1158     bool normalized = false,
1159     tflite::gpu::data::DataType normalized_type = tflite::gpu::data::DataType::UNKNOWN,
1160     flatbuffers::Offset<tflite::gpu::data::Int2> size = 0,
1161     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1162   Texture2DDescriptorBuilder builder_(_fbb);
1163   builder_.add_data(data);
1164   builder_.add_size(size);
1165   builder_.add_base_obj(base_obj);
1166   builder_.add_normalized_type(normalized_type);
1167   builder_.add_normalized(normalized);
1168   builder_.add_element_type(element_type);
1169   return builder_.Finish();
1170 }
1171 
1172 inline flatbuffers::Offset<Texture2DDescriptor> CreateTexture2DDescriptorDirect(
1173     flatbuffers::FlatBufferBuilder &_fbb,
1174     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1175     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1176     bool normalized = false,
1177     tflite::gpu::data::DataType normalized_type = tflite::gpu::data::DataType::UNKNOWN,
1178     flatbuffers::Offset<tflite::gpu::data::Int2> size = 0,
1179     const std::vector<uint8_t> *data = nullptr) {
1180   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1181   return tflite::gpu::data::CreateTexture2DDescriptor(
1182       _fbb,
1183       base_obj,
1184       element_type,
1185       normalized,
1186       normalized_type,
1187       size,
1188       data__);
1189 }
1190 
1191 struct TensorLinearDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1192   typedef TensorLinearDescriptorBuilder Builder;
1193   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1194     VT_BASE_OBJ = 4,
1195     VT_STORAGE_TYPE = 6,
1196     VT_ELEMENT_TYPE = 8,
1197     VT_MEMORY_TYPE = 10,
1198     VT_SIZE = 12,
1199     VT_DATA = 14
1200   };
base_objFLATBUFFERS_FINAL_CLASS1201   const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1202     return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1203   }
storage_typeFLATBUFFERS_FINAL_CLASS1204   tflite::gpu::data::LinearStorageType storage_type() const {
1205     return static_cast<tflite::gpu::data::LinearStorageType>(GetField<int8_t>(VT_STORAGE_TYPE, 0));
1206   }
element_typeFLATBUFFERS_FINAL_CLASS1207   tflite::gpu::data::DataType element_type() const {
1208     return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
1209   }
memory_typeFLATBUFFERS_FINAL_CLASS1210   tflite::gpu::data::MemoryType memory_type() const {
1211     return static_cast<tflite::gpu::data::MemoryType>(GetField<int8_t>(VT_MEMORY_TYPE, 0));
1212   }
sizeFLATBUFFERS_FINAL_CLASS1213   int32_t size() const {
1214     return GetField<int32_t>(VT_SIZE, 0);
1215   }
dataFLATBUFFERS_FINAL_CLASS1216   const flatbuffers::Vector<uint8_t> *data() const {
1217     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1218   }
VerifyFLATBUFFERS_FINAL_CLASS1219   bool Verify(flatbuffers::Verifier &verifier) const {
1220     return VerifyTableStart(verifier) &&
1221            VerifyOffset(verifier, VT_BASE_OBJ) &&
1222            verifier.VerifyTable(base_obj()) &&
1223            VerifyField<int8_t>(verifier, VT_STORAGE_TYPE) &&
1224            VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
1225            VerifyField<int8_t>(verifier, VT_MEMORY_TYPE) &&
1226            VerifyField<int32_t>(verifier, VT_SIZE) &&
1227            VerifyOffset(verifier, VT_DATA) &&
1228            verifier.VerifyVector(data()) &&
1229            verifier.EndTable();
1230   }
1231 };
1232 
1233 struct TensorLinearDescriptorBuilder {
1234   typedef TensorLinearDescriptor Table;
1235   flatbuffers::FlatBufferBuilder &fbb_;
1236   flatbuffers::uoffset_t start_;
add_base_objTensorLinearDescriptorBuilder1237   void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1238     fbb_.AddOffset(TensorLinearDescriptor::VT_BASE_OBJ, base_obj);
1239   }
add_storage_typeTensorLinearDescriptorBuilder1240   void add_storage_type(tflite::gpu::data::LinearStorageType storage_type) {
1241     fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_STORAGE_TYPE, static_cast<int8_t>(storage_type), 0);
1242   }
add_element_typeTensorLinearDescriptorBuilder1243   void add_element_type(tflite::gpu::data::DataType element_type) {
1244     fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1245   }
add_memory_typeTensorLinearDescriptorBuilder1246   void add_memory_type(tflite::gpu::data::MemoryType memory_type) {
1247     fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_MEMORY_TYPE, static_cast<int8_t>(memory_type), 0);
1248   }
add_sizeTensorLinearDescriptorBuilder1249   void add_size(int32_t size) {
1250     fbb_.AddElement<int32_t>(TensorLinearDescriptor::VT_SIZE, size, 0);
1251   }
add_dataTensorLinearDescriptorBuilder1252   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1253     fbb_.AddOffset(TensorLinearDescriptor::VT_DATA, data);
1254   }
TensorLinearDescriptorBuilderTensorLinearDescriptorBuilder1255   explicit TensorLinearDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1256         : fbb_(_fbb) {
1257     start_ = fbb_.StartTable();
1258   }
FinishTensorLinearDescriptorBuilder1259   flatbuffers::Offset<TensorLinearDescriptor> Finish() {
1260     const auto end = fbb_.EndTable(start_);
1261     auto o = flatbuffers::Offset<TensorLinearDescriptor>(end);
1262     return o;
1263   }
1264 };
1265 
1266 inline flatbuffers::Offset<TensorLinearDescriptor> CreateTensorLinearDescriptor(
1267     flatbuffers::FlatBufferBuilder &_fbb,
1268     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1269     tflite::gpu::data::LinearStorageType storage_type = tflite::gpu::data::LinearStorageType::BUFFER,
1270     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1271     tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1272     int32_t size = 0,
1273     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1274   TensorLinearDescriptorBuilder builder_(_fbb);
1275   builder_.add_data(data);
1276   builder_.add_size(size);
1277   builder_.add_base_obj(base_obj);
1278   builder_.add_memory_type(memory_type);
1279   builder_.add_element_type(element_type);
1280   builder_.add_storage_type(storage_type);
1281   return builder_.Finish();
1282 }
1283 
1284 inline flatbuffers::Offset<TensorLinearDescriptor> CreateTensorLinearDescriptorDirect(
1285     flatbuffers::FlatBufferBuilder &_fbb,
1286     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1287     tflite::gpu::data::LinearStorageType storage_type = tflite::gpu::data::LinearStorageType::BUFFER,
1288     tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1289     tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1290     int32_t size = 0,
1291     const std::vector<uint8_t> *data = nullptr) {
1292   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1293   return tflite::gpu::data::CreateTensorLinearDescriptor(
1294       _fbb,
1295       base_obj,
1296       storage_type,
1297       element_type,
1298       memory_type,
1299       size,
1300       data__);
1301 }
1302 
1303 struct BHWDC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1304   typedef BHWDCBuilder Builder;
1305   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1306     VT_B = 4,
1307     VT_H = 6,
1308     VT_W = 8,
1309     VT_D = 10,
1310     VT_C = 12
1311   };
bFLATBUFFERS_FINAL_CLASS1312   int32_t b() const {
1313     return GetField<int32_t>(VT_B, 0);
1314   }
hFLATBUFFERS_FINAL_CLASS1315   int32_t h() const {
1316     return GetField<int32_t>(VT_H, 0);
1317   }
wFLATBUFFERS_FINAL_CLASS1318   int32_t w() const {
1319     return GetField<int32_t>(VT_W, 0);
1320   }
dFLATBUFFERS_FINAL_CLASS1321   int32_t d() const {
1322     return GetField<int32_t>(VT_D, 0);
1323   }
cFLATBUFFERS_FINAL_CLASS1324   int32_t c() const {
1325     return GetField<int32_t>(VT_C, 0);
1326   }
VerifyFLATBUFFERS_FINAL_CLASS1327   bool Verify(flatbuffers::Verifier &verifier) const {
1328     return VerifyTableStart(verifier) &&
1329            VerifyField<int32_t>(verifier, VT_B) &&
1330            VerifyField<int32_t>(verifier, VT_H) &&
1331            VerifyField<int32_t>(verifier, VT_W) &&
1332            VerifyField<int32_t>(verifier, VT_D) &&
1333            VerifyField<int32_t>(verifier, VT_C) &&
1334            verifier.EndTable();
1335   }
1336 };
1337 
1338 struct BHWDCBuilder {
1339   typedef BHWDC Table;
1340   flatbuffers::FlatBufferBuilder &fbb_;
1341   flatbuffers::uoffset_t start_;
add_bBHWDCBuilder1342   void add_b(int32_t b) {
1343     fbb_.AddElement<int32_t>(BHWDC::VT_B, b, 0);
1344   }
add_hBHWDCBuilder1345   void add_h(int32_t h) {
1346     fbb_.AddElement<int32_t>(BHWDC::VT_H, h, 0);
1347   }
add_wBHWDCBuilder1348   void add_w(int32_t w) {
1349     fbb_.AddElement<int32_t>(BHWDC::VT_W, w, 0);
1350   }
add_dBHWDCBuilder1351   void add_d(int32_t d) {
1352     fbb_.AddElement<int32_t>(BHWDC::VT_D, d, 0);
1353   }
add_cBHWDCBuilder1354   void add_c(int32_t c) {
1355     fbb_.AddElement<int32_t>(BHWDC::VT_C, c, 0);
1356   }
BHWDCBuilderBHWDCBuilder1357   explicit BHWDCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1358         : fbb_(_fbb) {
1359     start_ = fbb_.StartTable();
1360   }
FinishBHWDCBuilder1361   flatbuffers::Offset<BHWDC> Finish() {
1362     const auto end = fbb_.EndTable(start_);
1363     auto o = flatbuffers::Offset<BHWDC>(end);
1364     return o;
1365   }
1366 };
1367 
1368 inline flatbuffers::Offset<BHWDC> CreateBHWDC(
1369     flatbuffers::FlatBufferBuilder &_fbb,
1370     int32_t b = 0,
1371     int32_t h = 0,
1372     int32_t w = 0,
1373     int32_t d = 0,
1374     int32_t c = 0) {
1375   BHWDCBuilder builder_(_fbb);
1376   builder_.add_c(c);
1377   builder_.add_d(d);
1378   builder_.add_w(w);
1379   builder_.add_h(h);
1380   builder_.add_b(b);
1381   return builder_.Finish();
1382 }
1383 
1384 struct TensorDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1385   typedef TensorDescriptorBuilder Builder;
1386   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1387     VT_BASE_OBJ = 4,
1388     VT_DATA_TYPE = 6,
1389     VT_STORAGE_TYPE = 8,
1390     VT_LAYOUT = 10,
1391     VT_SHAPE = 12,
1392     VT_DATA = 14
1393   };
base_objFLATBUFFERS_FINAL_CLASS1394   const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1395     return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1396   }
data_typeFLATBUFFERS_FINAL_CLASS1397   tflite::gpu::data::DataType data_type() const {
1398     return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_DATA_TYPE, 0));
1399   }
storage_typeFLATBUFFERS_FINAL_CLASS1400   tflite::gpu::data::TensorStorageType storage_type() const {
1401     return static_cast<tflite::gpu::data::TensorStorageType>(GetField<int8_t>(VT_STORAGE_TYPE, 0));
1402   }
layoutFLATBUFFERS_FINAL_CLASS1403   tflite::gpu::data::Layout layout() const {
1404     return static_cast<tflite::gpu::data::Layout>(GetField<int8_t>(VT_LAYOUT, 0));
1405   }
shapeFLATBUFFERS_FINAL_CLASS1406   const tflite::gpu::data::BHWDC *shape() const {
1407     return GetPointer<const tflite::gpu::data::BHWDC *>(VT_SHAPE);
1408   }
dataFLATBUFFERS_FINAL_CLASS1409   const flatbuffers::Vector<uint8_t> *data() const {
1410     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1411   }
VerifyFLATBUFFERS_FINAL_CLASS1412   bool Verify(flatbuffers::Verifier &verifier) const {
1413     return VerifyTableStart(verifier) &&
1414            VerifyOffset(verifier, VT_BASE_OBJ) &&
1415            verifier.VerifyTable(base_obj()) &&
1416            VerifyField<int8_t>(verifier, VT_DATA_TYPE) &&
1417            VerifyField<int8_t>(verifier, VT_STORAGE_TYPE) &&
1418            VerifyField<int8_t>(verifier, VT_LAYOUT) &&
1419            VerifyOffset(verifier, VT_SHAPE) &&
1420            verifier.VerifyTable(shape()) &&
1421            VerifyOffset(verifier, VT_DATA) &&
1422            verifier.VerifyVector(data()) &&
1423            verifier.EndTable();
1424   }
1425 };
1426 
1427 struct TensorDescriptorBuilder {
1428   typedef TensorDescriptor Table;
1429   flatbuffers::FlatBufferBuilder &fbb_;
1430   flatbuffers::uoffset_t start_;
add_base_objTensorDescriptorBuilder1431   void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1432     fbb_.AddOffset(TensorDescriptor::VT_BASE_OBJ, base_obj);
1433   }
add_data_typeTensorDescriptorBuilder1434   void add_data_type(tflite::gpu::data::DataType data_type) {
1435     fbb_.AddElement<int8_t>(TensorDescriptor::VT_DATA_TYPE, static_cast<int8_t>(data_type), 0);
1436   }
add_storage_typeTensorDescriptorBuilder1437   void add_storage_type(tflite::gpu::data::TensorStorageType storage_type) {
1438     fbb_.AddElement<int8_t>(TensorDescriptor::VT_STORAGE_TYPE, static_cast<int8_t>(storage_type), 0);
1439   }
add_layoutTensorDescriptorBuilder1440   void add_layout(tflite::gpu::data::Layout layout) {
1441     fbb_.AddElement<int8_t>(TensorDescriptor::VT_LAYOUT, static_cast<int8_t>(layout), 0);
1442   }
add_shapeTensorDescriptorBuilder1443   void add_shape(flatbuffers::Offset<tflite::gpu::data::BHWDC> shape) {
1444     fbb_.AddOffset(TensorDescriptor::VT_SHAPE, shape);
1445   }
add_dataTensorDescriptorBuilder1446   void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1447     fbb_.AddOffset(TensorDescriptor::VT_DATA, data);
1448   }
TensorDescriptorBuilderTensorDescriptorBuilder1449   explicit TensorDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1450         : fbb_(_fbb) {
1451     start_ = fbb_.StartTable();
1452   }
FinishTensorDescriptorBuilder1453   flatbuffers::Offset<TensorDescriptor> Finish() {
1454     const auto end = fbb_.EndTable(start_);
1455     auto o = flatbuffers::Offset<TensorDescriptor>(end);
1456     return o;
1457   }
1458 };
1459 
1460 inline flatbuffers::Offset<TensorDescriptor> CreateTensorDescriptor(
1461     flatbuffers::FlatBufferBuilder &_fbb,
1462     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1463     tflite::gpu::data::DataType data_type = tflite::gpu::data::DataType::UNKNOWN,
1464     tflite::gpu::data::TensorStorageType storage_type = tflite::gpu::data::TensorStorageType::UNKNOWN,
1465     tflite::gpu::data::Layout layout = tflite::gpu::data::Layout::UNKNOWN,
1466     flatbuffers::Offset<tflite::gpu::data::BHWDC> shape = 0,
1467     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1468   TensorDescriptorBuilder builder_(_fbb);
1469   builder_.add_data(data);
1470   builder_.add_shape(shape);
1471   builder_.add_base_obj(base_obj);
1472   builder_.add_layout(layout);
1473   builder_.add_storage_type(storage_type);
1474   builder_.add_data_type(data_type);
1475   return builder_.Finish();
1476 }
1477 
1478 inline flatbuffers::Offset<TensorDescriptor> CreateTensorDescriptorDirect(
1479     flatbuffers::FlatBufferBuilder &_fbb,
1480     flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1481     tflite::gpu::data::DataType data_type = tflite::gpu::data::DataType::UNKNOWN,
1482     tflite::gpu::data::TensorStorageType storage_type = tflite::gpu::data::TensorStorageType::UNKNOWN,
1483     tflite::gpu::data::Layout layout = tflite::gpu::data::Layout::UNKNOWN,
1484     flatbuffers::Offset<tflite::gpu::data::BHWDC> shape = 0,
1485     const std::vector<uint8_t> *data = nullptr) {
1486   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1487   return tflite::gpu::data::CreateTensorDescriptor(
1488       _fbb,
1489       base_obj,
1490       data_type,
1491       storage_type,
1492       layout,
1493       shape,
1494       data__);
1495 }
1496 
1497 struct BufferDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1498   typedef BufferDescriptorMapValueBuilder Builder;
1499   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1500     VT_KEY = 4,
1501     VT_VALUE = 6
1502   };
keyFLATBUFFERS_FINAL_CLASS1503   const flatbuffers::String *key() const {
1504     return GetPointer<const flatbuffers::String *>(VT_KEY);
1505   }
valueFLATBUFFERS_FINAL_CLASS1506   const tflite::gpu::data::BufferDescriptor *value() const {
1507     return GetPointer<const tflite::gpu::data::BufferDescriptor *>(VT_VALUE);
1508   }
VerifyFLATBUFFERS_FINAL_CLASS1509   bool Verify(flatbuffers::Verifier &verifier) const {
1510     return VerifyTableStart(verifier) &&
1511            VerifyOffset(verifier, VT_KEY) &&
1512            verifier.VerifyString(key()) &&
1513            VerifyOffset(verifier, VT_VALUE) &&
1514            verifier.VerifyTable(value()) &&
1515            verifier.EndTable();
1516   }
1517 };
1518 
1519 struct BufferDescriptorMapValueBuilder {
1520   typedef BufferDescriptorMapValue Table;
1521   flatbuffers::FlatBufferBuilder &fbb_;
1522   flatbuffers::uoffset_t start_;
add_keyBufferDescriptorMapValueBuilder1523   void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1524     fbb_.AddOffset(BufferDescriptorMapValue::VT_KEY, key);
1525   }
add_valueBufferDescriptorMapValueBuilder1526   void add_value(flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value) {
1527     fbb_.AddOffset(BufferDescriptorMapValue::VT_VALUE, value);
1528   }
BufferDescriptorMapValueBuilderBufferDescriptorMapValueBuilder1529   explicit BufferDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1530         : fbb_(_fbb) {
1531     start_ = fbb_.StartTable();
1532   }
FinishBufferDescriptorMapValueBuilder1533   flatbuffers::Offset<BufferDescriptorMapValue> Finish() {
1534     const auto end = fbb_.EndTable(start_);
1535     auto o = flatbuffers::Offset<BufferDescriptorMapValue>(end);
1536     return o;
1537   }
1538 };
1539 
1540 inline flatbuffers::Offset<BufferDescriptorMapValue> CreateBufferDescriptorMapValue(
1541     flatbuffers::FlatBufferBuilder &_fbb,
1542     flatbuffers::Offset<flatbuffers::String> key = 0,
1543     flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value = 0) {
1544   BufferDescriptorMapValueBuilder builder_(_fbb);
1545   builder_.add_value(value);
1546   builder_.add_key(key);
1547   return builder_.Finish();
1548 }
1549 
1550 inline flatbuffers::Offset<BufferDescriptorMapValue> CreateBufferDescriptorMapValueDirect(
1551     flatbuffers::FlatBufferBuilder &_fbb,
1552     const char *key = nullptr,
1553     flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value = 0) {
1554   auto key__ = key ? _fbb.CreateString(key) : 0;
1555   return tflite::gpu::data::CreateBufferDescriptorMapValue(
1556       _fbb,
1557       key__,
1558       value);
1559 }
1560 
1561 struct Texture2DDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1562   typedef Texture2DDescriptorMapValueBuilder Builder;
1563   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1564     VT_KEY = 4,
1565     VT_VALUE = 6
1566   };
keyFLATBUFFERS_FINAL_CLASS1567   const flatbuffers::String *key() const {
1568     return GetPointer<const flatbuffers::String *>(VT_KEY);
1569   }
valueFLATBUFFERS_FINAL_CLASS1570   const tflite::gpu::data::Texture2DDescriptor *value() const {
1571     return GetPointer<const tflite::gpu::data::Texture2DDescriptor *>(VT_VALUE);
1572   }
VerifyFLATBUFFERS_FINAL_CLASS1573   bool Verify(flatbuffers::Verifier &verifier) const {
1574     return VerifyTableStart(verifier) &&
1575            VerifyOffset(verifier, VT_KEY) &&
1576            verifier.VerifyString(key()) &&
1577            VerifyOffset(verifier, VT_VALUE) &&
1578            verifier.VerifyTable(value()) &&
1579            verifier.EndTable();
1580   }
1581 };
1582 
1583 struct Texture2DDescriptorMapValueBuilder {
1584   typedef Texture2DDescriptorMapValue Table;
1585   flatbuffers::FlatBufferBuilder &fbb_;
1586   flatbuffers::uoffset_t start_;
add_keyTexture2DDescriptorMapValueBuilder1587   void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1588     fbb_.AddOffset(Texture2DDescriptorMapValue::VT_KEY, key);
1589   }
add_valueTexture2DDescriptorMapValueBuilder1590   void add_value(flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value) {
1591     fbb_.AddOffset(Texture2DDescriptorMapValue::VT_VALUE, value);
1592   }
Texture2DDescriptorMapValueBuilderTexture2DDescriptorMapValueBuilder1593   explicit Texture2DDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1594         : fbb_(_fbb) {
1595     start_ = fbb_.StartTable();
1596   }
FinishTexture2DDescriptorMapValueBuilder1597   flatbuffers::Offset<Texture2DDescriptorMapValue> Finish() {
1598     const auto end = fbb_.EndTable(start_);
1599     auto o = flatbuffers::Offset<Texture2DDescriptorMapValue>(end);
1600     return o;
1601   }
1602 };
1603 
1604 inline flatbuffers::Offset<Texture2DDescriptorMapValue> CreateTexture2DDescriptorMapValue(
1605     flatbuffers::FlatBufferBuilder &_fbb,
1606     flatbuffers::Offset<flatbuffers::String> key = 0,
1607     flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value = 0) {
1608   Texture2DDescriptorMapValueBuilder builder_(_fbb);
1609   builder_.add_value(value);
1610   builder_.add_key(key);
1611   return builder_.Finish();
1612 }
1613 
1614 inline flatbuffers::Offset<Texture2DDescriptorMapValue> CreateTexture2DDescriptorMapValueDirect(
1615     flatbuffers::FlatBufferBuilder &_fbb,
1616     const char *key = nullptr,
1617     flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value = 0) {
1618   auto key__ = key ? _fbb.CreateString(key) : 0;
1619   return tflite::gpu::data::CreateTexture2DDescriptorMapValue(
1620       _fbb,
1621       key__,
1622       value);
1623 }
1624 
1625 struct TensorLinearDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1626   typedef TensorLinearDescriptorMapValueBuilder Builder;
1627   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1628     VT_KEY = 4,
1629     VT_VALUE = 6
1630   };
keyFLATBUFFERS_FINAL_CLASS1631   const flatbuffers::String *key() const {
1632     return GetPointer<const flatbuffers::String *>(VT_KEY);
1633   }
valueFLATBUFFERS_FINAL_CLASS1634   const tflite::gpu::data::TensorLinearDescriptor *value() const {
1635     return GetPointer<const tflite::gpu::data::TensorLinearDescriptor *>(VT_VALUE);
1636   }
VerifyFLATBUFFERS_FINAL_CLASS1637   bool Verify(flatbuffers::Verifier &verifier) const {
1638     return VerifyTableStart(verifier) &&
1639            VerifyOffset(verifier, VT_KEY) &&
1640            verifier.VerifyString(key()) &&
1641            VerifyOffset(verifier, VT_VALUE) &&
1642            verifier.VerifyTable(value()) &&
1643            verifier.EndTable();
1644   }
1645 };
1646 
1647 struct TensorLinearDescriptorMapValueBuilder {
1648   typedef TensorLinearDescriptorMapValue Table;
1649   flatbuffers::FlatBufferBuilder &fbb_;
1650   flatbuffers::uoffset_t start_;
add_keyTensorLinearDescriptorMapValueBuilder1651   void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1652     fbb_.AddOffset(TensorLinearDescriptorMapValue::VT_KEY, key);
1653   }
add_valueTensorLinearDescriptorMapValueBuilder1654   void add_value(flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value) {
1655     fbb_.AddOffset(TensorLinearDescriptorMapValue::VT_VALUE, value);
1656   }
TensorLinearDescriptorMapValueBuilderTensorLinearDescriptorMapValueBuilder1657   explicit TensorLinearDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1658         : fbb_(_fbb) {
1659     start_ = fbb_.StartTable();
1660   }
FinishTensorLinearDescriptorMapValueBuilder1661   flatbuffers::Offset<TensorLinearDescriptorMapValue> Finish() {
1662     const auto end = fbb_.EndTable(start_);
1663     auto o = flatbuffers::Offset<TensorLinearDescriptorMapValue>(end);
1664     return o;
1665   }
1666 };
1667 
1668 inline flatbuffers::Offset<TensorLinearDescriptorMapValue> CreateTensorLinearDescriptorMapValue(
1669     flatbuffers::FlatBufferBuilder &_fbb,
1670     flatbuffers::Offset<flatbuffers::String> key = 0,
1671     flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value = 0) {
1672   TensorLinearDescriptorMapValueBuilder builder_(_fbb);
1673   builder_.add_value(value);
1674   builder_.add_key(key);
1675   return builder_.Finish();
1676 }
1677 
1678 inline flatbuffers::Offset<TensorLinearDescriptorMapValue> CreateTensorLinearDescriptorMapValueDirect(
1679     flatbuffers::FlatBufferBuilder &_fbb,
1680     const char *key = nullptr,
1681     flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value = 0) {
1682   auto key__ = key ? _fbb.CreateString(key) : 0;
1683   return tflite::gpu::data::CreateTensorLinearDescriptorMapValue(
1684       _fbb,
1685       key__,
1686       value);
1687 }
1688 
1689 struct TensorDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1690   typedef TensorDescriptorMapValueBuilder Builder;
1691   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1692     VT_KEY = 4,
1693     VT_VALUE = 6
1694   };
keyFLATBUFFERS_FINAL_CLASS1695   const flatbuffers::String *key() const {
1696     return GetPointer<const flatbuffers::String *>(VT_KEY);
1697   }
valueFLATBUFFERS_FINAL_CLASS1698   const tflite::gpu::data::TensorDescriptor *value() const {
1699     return GetPointer<const tflite::gpu::data::TensorDescriptor *>(VT_VALUE);
1700   }
VerifyFLATBUFFERS_FINAL_CLASS1701   bool Verify(flatbuffers::Verifier &verifier) const {
1702     return VerifyTableStart(verifier) &&
1703            VerifyOffset(verifier, VT_KEY) &&
1704            verifier.VerifyString(key()) &&
1705            VerifyOffset(verifier, VT_VALUE) &&
1706            verifier.VerifyTable(value()) &&
1707            verifier.EndTable();
1708   }
1709 };
1710 
1711 struct TensorDescriptorMapValueBuilder {
1712   typedef TensorDescriptorMapValue Table;
1713   flatbuffers::FlatBufferBuilder &fbb_;
1714   flatbuffers::uoffset_t start_;
add_keyTensorDescriptorMapValueBuilder1715   void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1716     fbb_.AddOffset(TensorDescriptorMapValue::VT_KEY, key);
1717   }
add_valueTensorDescriptorMapValueBuilder1718   void add_value(flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value) {
1719     fbb_.AddOffset(TensorDescriptorMapValue::VT_VALUE, value);
1720   }
TensorDescriptorMapValueBuilderTensorDescriptorMapValueBuilder1721   explicit TensorDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1722         : fbb_(_fbb) {
1723     start_ = fbb_.StartTable();
1724   }
FinishTensorDescriptorMapValueBuilder1725   flatbuffers::Offset<TensorDescriptorMapValue> Finish() {
1726     const auto end = fbb_.EndTable(start_);
1727     auto o = flatbuffers::Offset<TensorDescriptorMapValue>(end);
1728     return o;
1729   }
1730 };
1731 
1732 inline flatbuffers::Offset<TensorDescriptorMapValue> CreateTensorDescriptorMapValue(
1733     flatbuffers::FlatBufferBuilder &_fbb,
1734     flatbuffers::Offset<flatbuffers::String> key = 0,
1735     flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value = 0) {
1736   TensorDescriptorMapValueBuilder builder_(_fbb);
1737   builder_.add_value(value);
1738   builder_.add_key(key);
1739   return builder_.Finish();
1740 }
1741 
1742 inline flatbuffers::Offset<TensorDescriptorMapValue> CreateTensorDescriptorMapValueDirect(
1743     flatbuffers::FlatBufferBuilder &_fbb,
1744     const char *key = nullptr,
1745     flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value = 0) {
1746   auto key__ = key ? _fbb.CreateString(key) : 0;
1747   return tflite::gpu::data::CreateTensorDescriptorMapValue(
1748       _fbb,
1749       key__,
1750       value);
1751 }
1752 
1753 struct Arguments FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1754   typedef ArgumentsBuilder Builder;
1755   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1756     VT_INT_VALUES = 4,
1757     VT_FLOAT_VALUES = 6,
1758     VT_HALF_VALUES = 8,
1759     VT_BUFFER_REFS = 10,
1760     VT_TEXTURE2D_REFS = 12,
1761     VT_TENSOR_LINEAR_REFS = 14,
1762     VT_TENSOR_REFS = 16,
1763     VT_BUFFER_OBJECTS = 18,
1764     VT_TEXTURE2D_OBJECTS = 20,
1765     VT_TENSOR_LINEAR_OBJECTS = 22,
1766     VT_TENSOR_OBJECTS = 24
1767   };
int_valuesFLATBUFFERS_FINAL_CLASS1768   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *int_values() const {
1769     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *>(VT_INT_VALUES);
1770   }
float_valuesFLATBUFFERS_FINAL_CLASS1771   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *float_values() const {
1772     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *>(VT_FLOAT_VALUES);
1773   }
half_valuesFLATBUFFERS_FINAL_CLASS1774   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *half_values() const {
1775     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *>(VT_HALF_VALUES);
1776   }
buffer_refsFLATBUFFERS_FINAL_CLASS1777   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_refs() const {
1778     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *>(VT_BUFFER_REFS);
1779   }
texture2d_refsFLATBUFFERS_FINAL_CLASS1780   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_refs() const {
1781     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *>(VT_TEXTURE2D_REFS);
1782   }
tensor_linear_refsFLATBUFFERS_FINAL_CLASS1783   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_refs() const {
1784     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *>(VT_TENSOR_LINEAR_REFS);
1785   }
tensor_refsFLATBUFFERS_FINAL_CLASS1786   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_refs() const {
1787     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *>(VT_TENSOR_REFS);
1788   }
buffer_objectsFLATBUFFERS_FINAL_CLASS1789   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_objects() const {
1790     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *>(VT_BUFFER_OBJECTS);
1791   }
texture2d_objectsFLATBUFFERS_FINAL_CLASS1792   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_objects() const {
1793     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *>(VT_TEXTURE2D_OBJECTS);
1794   }
tensor_linear_objectsFLATBUFFERS_FINAL_CLASS1795   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_objects() const {
1796     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *>(VT_TENSOR_LINEAR_OBJECTS);
1797   }
tensor_objectsFLATBUFFERS_FINAL_CLASS1798   const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_objects() const {
1799     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *>(VT_TENSOR_OBJECTS);
1800   }
VerifyFLATBUFFERS_FINAL_CLASS1801   bool Verify(flatbuffers::Verifier &verifier) const {
1802     return VerifyTableStart(verifier) &&
1803            VerifyOffset(verifier, VT_INT_VALUES) &&
1804            verifier.VerifyVector(int_values()) &&
1805            verifier.VerifyVectorOfTables(int_values()) &&
1806            VerifyOffset(verifier, VT_FLOAT_VALUES) &&
1807            verifier.VerifyVector(float_values()) &&
1808            verifier.VerifyVectorOfTables(float_values()) &&
1809            VerifyOffset(verifier, VT_HALF_VALUES) &&
1810            verifier.VerifyVector(half_values()) &&
1811            verifier.VerifyVectorOfTables(half_values()) &&
1812            VerifyOffset(verifier, VT_BUFFER_REFS) &&
1813            verifier.VerifyVector(buffer_refs()) &&
1814            verifier.VerifyVectorOfTables(buffer_refs()) &&
1815            VerifyOffset(verifier, VT_TEXTURE2D_REFS) &&
1816            verifier.VerifyVector(texture2d_refs()) &&
1817            verifier.VerifyVectorOfTables(texture2d_refs()) &&
1818            VerifyOffset(verifier, VT_TENSOR_LINEAR_REFS) &&
1819            verifier.VerifyVector(tensor_linear_refs()) &&
1820            verifier.VerifyVectorOfTables(tensor_linear_refs()) &&
1821            VerifyOffset(verifier, VT_TENSOR_REFS) &&
1822            verifier.VerifyVector(tensor_refs()) &&
1823            verifier.VerifyVectorOfTables(tensor_refs()) &&
1824            VerifyOffset(verifier, VT_BUFFER_OBJECTS) &&
1825            verifier.VerifyVector(buffer_objects()) &&
1826            verifier.VerifyVectorOfTables(buffer_objects()) &&
1827            VerifyOffset(verifier, VT_TEXTURE2D_OBJECTS) &&
1828            verifier.VerifyVector(texture2d_objects()) &&
1829            verifier.VerifyVectorOfTables(texture2d_objects()) &&
1830            VerifyOffset(verifier, VT_TENSOR_LINEAR_OBJECTS) &&
1831            verifier.VerifyVector(tensor_linear_objects()) &&
1832            verifier.VerifyVectorOfTables(tensor_linear_objects()) &&
1833            VerifyOffset(verifier, VT_TENSOR_OBJECTS) &&
1834            verifier.VerifyVector(tensor_objects()) &&
1835            verifier.VerifyVectorOfTables(tensor_objects()) &&
1836            verifier.EndTable();
1837   }
1838 };
1839 
1840 struct ArgumentsBuilder {
1841   typedef Arguments Table;
1842   flatbuffers::FlatBufferBuilder &fbb_;
1843   flatbuffers::uoffset_t start_;
add_int_valuesArgumentsBuilder1844   void add_int_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>>> int_values) {
1845     fbb_.AddOffset(Arguments::VT_INT_VALUES, int_values);
1846   }
add_float_valuesArgumentsBuilder1847   void add_float_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>> float_values) {
1848     fbb_.AddOffset(Arguments::VT_FLOAT_VALUES, float_values);
1849   }
add_half_valuesArgumentsBuilder1850   void add_half_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>> half_values) {
1851     fbb_.AddOffset(Arguments::VT_HALF_VALUES, half_values);
1852   }
add_buffer_refsArgumentsBuilder1853   void add_buffer_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_refs) {
1854     fbb_.AddOffset(Arguments::VT_BUFFER_REFS, buffer_refs);
1855   }
add_texture2d_refsArgumentsBuilder1856   void add_texture2d_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_refs) {
1857     fbb_.AddOffset(Arguments::VT_TEXTURE2D_REFS, texture2d_refs);
1858   }
add_tensor_linear_refsArgumentsBuilder1859   void add_tensor_linear_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_refs) {
1860     fbb_.AddOffset(Arguments::VT_TENSOR_LINEAR_REFS, tensor_linear_refs);
1861   }
add_tensor_refsArgumentsBuilder1862   void add_tensor_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_refs) {
1863     fbb_.AddOffset(Arguments::VT_TENSOR_REFS, tensor_refs);
1864   }
add_buffer_objectsArgumentsBuilder1865   void add_buffer_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_objects) {
1866     fbb_.AddOffset(Arguments::VT_BUFFER_OBJECTS, buffer_objects);
1867   }
add_texture2d_objectsArgumentsBuilder1868   void add_texture2d_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_objects) {
1869     fbb_.AddOffset(Arguments::VT_TEXTURE2D_OBJECTS, texture2d_objects);
1870   }
add_tensor_linear_objectsArgumentsBuilder1871   void add_tensor_linear_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_objects) {
1872     fbb_.AddOffset(Arguments::VT_TENSOR_LINEAR_OBJECTS, tensor_linear_objects);
1873   }
add_tensor_objectsArgumentsBuilder1874   void add_tensor_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_objects) {
1875     fbb_.AddOffset(Arguments::VT_TENSOR_OBJECTS, tensor_objects);
1876   }
ArgumentsBuilderArgumentsBuilder1877   explicit ArgumentsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1878         : fbb_(_fbb) {
1879     start_ = fbb_.StartTable();
1880   }
FinishArgumentsBuilder1881   flatbuffers::Offset<Arguments> Finish() {
1882     const auto end = fbb_.EndTable(start_);
1883     auto o = flatbuffers::Offset<Arguments>(end);
1884     return o;
1885   }
1886 };
1887 
1888 inline flatbuffers::Offset<Arguments> CreateArguments(
1889     flatbuffers::FlatBufferBuilder &_fbb,
1890     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>>> int_values = 0,
1891     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>> float_values = 0,
1892     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>> half_values = 0,
1893     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_refs = 0,
1894     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_refs = 0,
1895     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_refs = 0,
1896     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_refs = 0,
1897     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_objects = 0,
1898     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_objects = 0,
1899     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_objects = 0,
1900     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_objects = 0) {
1901   ArgumentsBuilder builder_(_fbb);
1902   builder_.add_tensor_objects(tensor_objects);
1903   builder_.add_tensor_linear_objects(tensor_linear_objects);
1904   builder_.add_texture2d_objects(texture2d_objects);
1905   builder_.add_buffer_objects(buffer_objects);
1906   builder_.add_tensor_refs(tensor_refs);
1907   builder_.add_tensor_linear_refs(tensor_linear_refs);
1908   builder_.add_texture2d_refs(texture2d_refs);
1909   builder_.add_buffer_refs(buffer_refs);
1910   builder_.add_half_values(half_values);
1911   builder_.add_float_values(float_values);
1912   builder_.add_int_values(int_values);
1913   return builder_.Finish();
1914 }
1915 
1916 inline flatbuffers::Offset<Arguments> CreateArgumentsDirect(
1917     flatbuffers::FlatBufferBuilder &_fbb,
1918     const std::vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *int_values = nullptr,
1919     const std::vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *float_values = nullptr,
1920     const std::vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *half_values = nullptr,
1921     const std::vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_refs = nullptr,
1922     const std::vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_refs = nullptr,
1923     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_refs = nullptr,
1924     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_refs = nullptr,
1925     const std::vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_objects = nullptr,
1926     const std::vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_objects = nullptr,
1927     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_objects = nullptr,
1928     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_objects = nullptr) {
1929   auto int_values__ = int_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::IntValue>>(*int_values) : 0;
1930   auto float_values__ = float_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>(*float_values) : 0;
1931   auto half_values__ = half_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>(*half_values) : 0;
1932   auto buffer_refs__ = buffer_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>(*buffer_refs) : 0;
1933   auto texture2d_refs__ = texture2d_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>(*texture2d_refs) : 0;
1934   auto tensor_linear_refs__ = tensor_linear_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>(*tensor_linear_refs) : 0;
1935   auto tensor_refs__ = tensor_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>(*tensor_refs) : 0;
1936   auto buffer_objects__ = buffer_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>(*buffer_objects) : 0;
1937   auto texture2d_objects__ = texture2d_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>(*texture2d_objects) : 0;
1938   auto tensor_linear_objects__ = tensor_linear_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>(*tensor_linear_objects) : 0;
1939   auto tensor_objects__ = tensor_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>(*tensor_objects) : 0;
1940   return tflite::gpu::data::CreateArguments(
1941       _fbb,
1942       int_values__,
1943       float_values__,
1944       half_values__,
1945       buffer_refs__,
1946       texture2d_refs__,
1947       tensor_linear_refs__,
1948       tensor_refs__,
1949       buffer_objects__,
1950       texture2d_objects__,
1951       tensor_linear_objects__,
1952       tensor_objects__);
1953 }
1954 
1955 struct OperationDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1956   typedef OperationDefBuilder Builder;
1957   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1958     VT_PRECISION = 4,
1959     VT_SRC_TENSORS = 6,
1960     VT_DST_TENSORS = 8
1961   };
precisionFLATBUFFERS_FINAL_CLASS1962   tflite::gpu::data::CalculationsPrecision precision() const {
1963     return static_cast<tflite::gpu::data::CalculationsPrecision>(
1964         GetField<int8_t>(VT_PRECISION, 0));
1965   }
1966   const flatbuffers::Vector<
1967       flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
src_tensorsFLATBUFFERS_FINAL_CLASS1968       *src_tensors() const {
1969     return GetPointer<const flatbuffers::Vector<
1970         flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>> *>(
1971         VT_SRC_TENSORS);
1972   }
1973   const flatbuffers::Vector<
1974       flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
dst_tensorsFLATBUFFERS_FINAL_CLASS1975       *dst_tensors() const {
1976     return GetPointer<const flatbuffers::Vector<
1977         flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>> *>(
1978         VT_DST_TENSORS);
1979   }
VerifyFLATBUFFERS_FINAL_CLASS1980   bool Verify(flatbuffers::Verifier &verifier) const {
1981     return VerifyTableStart(verifier) &&
1982            VerifyField<int8_t>(verifier, VT_PRECISION) &&
1983            VerifyOffset(verifier, VT_SRC_TENSORS) &&
1984            verifier.VerifyVector(src_tensors()) &&
1985            verifier.VerifyVectorOfTables(src_tensors()) &&
1986            VerifyOffset(verifier, VT_DST_TENSORS) &&
1987            verifier.VerifyVector(dst_tensors()) &&
1988            verifier.VerifyVectorOfTables(dst_tensors()) && verifier.EndTable();
1989   }
1990 };
1991 
1992 struct OperationDefBuilder {
1993   typedef OperationDef Table;
1994   flatbuffers::FlatBufferBuilder &fbb_;
1995   flatbuffers::uoffset_t start_;
add_precisionOperationDefBuilder1996   void add_precision(tflite::gpu::data::CalculationsPrecision precision) {
1997     fbb_.AddElement<int8_t>(OperationDef::VT_PRECISION,
1998                             static_cast<int8_t>(precision), 0);
1999   }
add_src_tensorsOperationDefBuilder2000   void add_src_tensors(
2001       flatbuffers::Offset<flatbuffers::Vector<
2002           flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2003           src_tensors) {
2004     fbb_.AddOffset(OperationDef::VT_SRC_TENSORS, src_tensors);
2005   }
add_dst_tensorsOperationDefBuilder2006   void add_dst_tensors(
2007       flatbuffers::Offset<flatbuffers::Vector<
2008           flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2009           dst_tensors) {
2010     fbb_.AddOffset(OperationDef::VT_DST_TENSORS, dst_tensors);
2011   }
OperationDefBuilderOperationDefBuilder2012   explicit OperationDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2013       : fbb_(_fbb) {
2014     start_ = fbb_.StartTable();
2015   }
FinishOperationDefBuilder2016   flatbuffers::Offset<OperationDef> Finish() {
2017     const auto end = fbb_.EndTable(start_);
2018     auto o = flatbuffers::Offset<OperationDef>(end);
2019     return o;
2020   }
2021 };
2022 
2023 inline flatbuffers::Offset<OperationDef> CreateOperationDef(
2024     flatbuffers::FlatBufferBuilder &_fbb,
2025     tflite::gpu::data::CalculationsPrecision precision =
2026         tflite::gpu::data::CalculationsPrecision::F32,
2027     flatbuffers::Offset<flatbuffers::Vector<
2028         flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2029         src_tensors = 0,
2030     flatbuffers::Offset<flatbuffers::Vector<
2031         flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2032         dst_tensors = 0) {
2033   OperationDefBuilder builder_(_fbb);
2034   builder_.add_dst_tensors(dst_tensors);
2035   builder_.add_src_tensors(src_tensors);
2036   builder_.add_precision(precision);
2037   return builder_.Finish();
2038 }
2039 
2040 inline flatbuffers::Offset<OperationDef> CreateOperationDefDirect(
2041     flatbuffers::FlatBufferBuilder &_fbb,
2042     tflite::gpu::data::CalculationsPrecision precision =
2043         tflite::gpu::data::CalculationsPrecision::F32,
2044     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
2045         *src_tensors = nullptr,
2046     const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
2047         *dst_tensors = nullptr) {
2048   auto src_tensors__ =
2049       src_tensors
2050           ? _fbb.CreateVector<
2051                 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>(
2052                 *src_tensors)
2053           : 0;
2054   auto dst_tensors__ =
2055       dst_tensors
2056           ? _fbb.CreateVector<
2057                 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>(
2058                 *dst_tensors)
2059           : 0;
2060   return tflite::gpu::data::CreateOperationDef(_fbb, precision, src_tensors__,
2061                                                dst_tensors__);
2062 }
2063 
2064 struct CompilerOption FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2065   typedef CompilerOptionBuilder Builder;
2066   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2067     VT_OPTION = 4
2068   };
optionFLATBUFFERS_FINAL_CLASS2069   tflite::gpu::data::CompilerOptions option() const {
2070     return static_cast<tflite::gpu::data::CompilerOptions>(
2071         GetField<int8_t>(VT_OPTION, 0));
2072   }
VerifyFLATBUFFERS_FINAL_CLASS2073   bool Verify(flatbuffers::Verifier &verifier) const {
2074     return VerifyTableStart(verifier) &&
2075            VerifyField<int8_t>(verifier, VT_OPTION) && verifier.EndTable();
2076   }
2077 };
2078 
2079 struct CompilerOptionBuilder {
2080   typedef CompilerOption Table;
2081   flatbuffers::FlatBufferBuilder &fbb_;
2082   flatbuffers::uoffset_t start_;
add_optionCompilerOptionBuilder2083   void add_option(tflite::gpu::data::CompilerOptions option) {
2084     fbb_.AddElement<int8_t>(CompilerOption::VT_OPTION,
2085                             static_cast<int8_t>(option), 0);
2086   }
CompilerOptionBuilderCompilerOptionBuilder2087   explicit CompilerOptionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2088       : fbb_(_fbb) {
2089     start_ = fbb_.StartTable();
2090   }
FinishCompilerOptionBuilder2091   flatbuffers::Offset<CompilerOption> Finish() {
2092     const auto end = fbb_.EndTable(start_);
2093     auto o = flatbuffers::Offset<CompilerOption>(end);
2094     return o;
2095   }
2096 };
2097 
2098 inline flatbuffers::Offset<CompilerOption> CreateCompilerOption(
2099     flatbuffers::FlatBufferBuilder &_fbb,
2100     tflite::gpu::data::CompilerOptions option =
2101         tflite::gpu::data::CompilerOptions::ADRENO_FULL_SIMD_LINE) {
2102   CompilerOptionBuilder builder_(_fbb);
2103   builder_.add_option(option);
2104   return builder_.Finish();
2105 }
2106 
2107 struct GPUOperation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2108   typedef GPUOperationBuilder Builder;
2109   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2110     VT_ARGUMENTS = 4,
2111     VT_CODE = 6,
2112     VT_WORK_GROUP_SIZE = 8,
2113     VT_COMPILER_OPTIONS = 10,
2114     VT_TENSOR_TO_GRID = 12,
2115     VT_ELEMENTWISE = 14,
2116     VT_LINKABLE = 16,
2117     VT_CHECK_SRC_CHANNELS_SIZE = 18,
2118     VT_DEFINITION = 20,
2119     VT_GRID_DIMENSION = 22,
2120     VT_WORK_GROUP_LAUNCH_ORDER = 24,
2121     VT_GRID_SIZE = 26,
2122     VT_SRC_TENSORS_NAMES = 28,
2123     VT_DST_TENSORS_NAMES = 30,
2124     VT_WORK_GROUPS_COUNT = 32,
2125     VT_LINKABLE_COUNT = 34,
2126     VT_ELEMENTWISE_CODE = 36
2127   };
argumentsFLATBUFFERS_FINAL_CLASS2128   const tflite::gpu::data::Arguments *arguments() const {
2129     return GetPointer<const tflite::gpu::data::Arguments *>(VT_ARGUMENTS);
2130   }
codeFLATBUFFERS_FINAL_CLASS2131   const flatbuffers::String *code() const {
2132     return GetPointer<const flatbuffers::String *>(VT_CODE);
2133   }
work_group_sizeFLATBUFFERS_FINAL_CLASS2134   const tflite::gpu::data::Int3 *work_group_size() const {
2135     return GetPointer<const tflite::gpu::data::Int3 *>(VT_WORK_GROUP_SIZE);
2136   }
2137   const flatbuffers::Vector<
2138       flatbuffers::Offset<tflite::gpu::data::CompilerOption>>
compiler_optionsFLATBUFFERS_FINAL_CLASS2139       *compiler_options() const {
2140     return GetPointer<const flatbuffers::Vector<
2141         flatbuffers::Offset<tflite::gpu::data::CompilerOption>> *>(
2142         VT_COMPILER_OPTIONS);
2143   }
tensor_to_gridFLATBUFFERS_FINAL_CLASS2144   tflite::gpu::data::TensorToGrid tensor_to_grid() const {
2145     return static_cast<tflite::gpu::data::TensorToGrid>(
2146         GetField<int8_t>(VT_TENSOR_TO_GRID, 0));
2147   }
elementwiseFLATBUFFERS_FINAL_CLASS2148   bool elementwise() const { return GetField<uint8_t>(VT_ELEMENTWISE, 0) != 0; }
linkableFLATBUFFERS_FINAL_CLASS2149   bool linkable() const { return GetField<uint8_t>(VT_LINKABLE, 0) != 0; }
check_src_channels_sizeFLATBUFFERS_FINAL_CLASS2150   bool check_src_channels_size() const {
2151     return GetField<uint8_t>(VT_CHECK_SRC_CHANNELS_SIZE, 0) != 0;
2152   }
definitionFLATBUFFERS_FINAL_CLASS2153   const tflite::gpu::data::OperationDef *definition() const {
2154     return GetPointer<const tflite::gpu::data::OperationDef *>(VT_DEFINITION);
2155   }
grid_dimensionFLATBUFFERS_FINAL_CLASS2156   int32_t grid_dimension() const {
2157     return GetField<int32_t>(VT_GRID_DIMENSION, 0);
2158   }
work_group_launch_orderFLATBUFFERS_FINAL_CLASS2159   const tflite::gpu::data::Int3 *work_group_launch_order() const {
2160     return GetPointer<const tflite::gpu::data::Int3 *>(
2161         VT_WORK_GROUP_LAUNCH_ORDER);
2162   }
grid_sizeFLATBUFFERS_FINAL_CLASS2163   const tflite::gpu::data::Int3 *grid_size() const {
2164     return GetPointer<const tflite::gpu::data::Int3 *>(VT_GRID_SIZE);
2165   }
2166   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>
src_tensors_namesFLATBUFFERS_FINAL_CLASS2167       *src_tensors_names() const {
2168     return GetPointer<
2169         const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
2170         VT_SRC_TENSORS_NAMES);
2171   }
2172   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>
dst_tensors_namesFLATBUFFERS_FINAL_CLASS2173       *dst_tensors_names() const {
2174     return GetPointer<
2175         const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
2176         VT_DST_TENSORS_NAMES);
2177   }
work_groups_countFLATBUFFERS_FINAL_CLASS2178   const tflite::gpu::data::Int3 *work_groups_count() const {
2179     return GetPointer<const tflite::gpu::data::Int3 *>(VT_WORK_GROUPS_COUNT);
2180   }
linkable_countFLATBUFFERS_FINAL_CLASS2181   int32_t linkable_count() const {
2182     return GetField<int32_t>(VT_LINKABLE_COUNT, 0);
2183   }
elementwise_codeFLATBUFFERS_FINAL_CLASS2184   const flatbuffers::String *elementwise_code() const {
2185     return GetPointer<const flatbuffers::String *>(VT_ELEMENTWISE_CODE);
2186   }
VerifyFLATBUFFERS_FINAL_CLASS2187   bool Verify(flatbuffers::Verifier &verifier) const {
2188     return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_ARGUMENTS) &&
2189            verifier.VerifyTable(arguments()) &&
2190            VerifyOffset(verifier, VT_CODE) && verifier.VerifyString(code()) &&
2191            VerifyOffset(verifier, VT_WORK_GROUP_SIZE) &&
2192            verifier.VerifyTable(work_group_size()) &&
2193            VerifyOffset(verifier, VT_COMPILER_OPTIONS) &&
2194            verifier.VerifyVector(compiler_options()) &&
2195            verifier.VerifyVectorOfTables(compiler_options()) &&
2196            VerifyField<int8_t>(verifier, VT_TENSOR_TO_GRID) &&
2197            VerifyField<uint8_t>(verifier, VT_ELEMENTWISE) &&
2198            VerifyField<uint8_t>(verifier, VT_LINKABLE) &&
2199            VerifyField<uint8_t>(verifier, VT_CHECK_SRC_CHANNELS_SIZE) &&
2200            VerifyOffset(verifier, VT_DEFINITION) &&
2201            verifier.VerifyTable(definition()) &&
2202            VerifyField<int32_t>(verifier, VT_GRID_DIMENSION) &&
2203            VerifyOffset(verifier, VT_WORK_GROUP_LAUNCH_ORDER) &&
2204            verifier.VerifyTable(work_group_launch_order()) &&
2205            VerifyOffset(verifier, VT_GRID_SIZE) &&
2206            verifier.VerifyTable(grid_size()) &&
2207            VerifyOffset(verifier, VT_SRC_TENSORS_NAMES) &&
2208            verifier.VerifyVector(src_tensors_names()) &&
2209            verifier.VerifyVectorOfStrings(src_tensors_names()) &&
2210            VerifyOffset(verifier, VT_DST_TENSORS_NAMES) &&
2211            verifier.VerifyVector(dst_tensors_names()) &&
2212            verifier.VerifyVectorOfStrings(dst_tensors_names()) &&
2213            VerifyOffset(verifier, VT_WORK_GROUPS_COUNT) &&
2214            verifier.VerifyTable(work_groups_count()) &&
2215            VerifyField<int32_t>(verifier, VT_LINKABLE_COUNT) &&
2216            VerifyOffset(verifier, VT_ELEMENTWISE_CODE) &&
2217            verifier.VerifyString(elementwise_code()) && verifier.EndTable();
2218   }
2219 };
2220 
2221 struct GPUOperationBuilder {
2222   typedef GPUOperation Table;
2223   flatbuffers::FlatBufferBuilder &fbb_;
2224   flatbuffers::uoffset_t start_;
add_argumentsGPUOperationBuilder2225   void add_arguments(
2226       flatbuffers::Offset<tflite::gpu::data::Arguments> arguments) {
2227     fbb_.AddOffset(GPUOperation::VT_ARGUMENTS, arguments);
2228   }
add_codeGPUOperationBuilder2229   void add_code(flatbuffers::Offset<flatbuffers::String> code) {
2230     fbb_.AddOffset(GPUOperation::VT_CODE, code);
2231   }
add_work_group_sizeGPUOperationBuilder2232   void add_work_group_size(
2233       flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size) {
2234     fbb_.AddOffset(GPUOperation::VT_WORK_GROUP_SIZE, work_group_size);
2235   }
add_compiler_optionsGPUOperationBuilder2236   void add_compiler_options(
2237       flatbuffers::Offset<flatbuffers::Vector<
2238           flatbuffers::Offset<tflite::gpu::data::CompilerOption>>>
2239           compiler_options) {
2240     fbb_.AddOffset(GPUOperation::VT_COMPILER_OPTIONS, compiler_options);
2241   }
add_tensor_to_gridGPUOperationBuilder2242   void add_tensor_to_grid(tflite::gpu::data::TensorToGrid tensor_to_grid) {
2243     fbb_.AddElement<int8_t>(GPUOperation::VT_TENSOR_TO_GRID,
2244                             static_cast<int8_t>(tensor_to_grid), 0);
2245   }
add_elementwiseGPUOperationBuilder2246   void add_elementwise(bool elementwise) {
2247     fbb_.AddElement<uint8_t>(GPUOperation::VT_ELEMENTWISE,
2248                              static_cast<uint8_t>(elementwise), 0);
2249   }
add_linkableGPUOperationBuilder2250   void add_linkable(bool linkable) {
2251     fbb_.AddElement<uint8_t>(GPUOperation::VT_LINKABLE,
2252                              static_cast<uint8_t>(linkable), 0);
2253   }
add_check_src_channels_sizeGPUOperationBuilder2254   void add_check_src_channels_size(bool check_src_channels_size) {
2255     fbb_.AddElement<uint8_t>(GPUOperation::VT_CHECK_SRC_CHANNELS_SIZE,
2256                              static_cast<uint8_t>(check_src_channels_size), 0);
2257   }
add_definitionGPUOperationBuilder2258   void add_definition(
2259       flatbuffers::Offset<tflite::gpu::data::OperationDef> definition) {
2260     fbb_.AddOffset(GPUOperation::VT_DEFINITION, definition);
2261   }
add_grid_dimensionGPUOperationBuilder2262   void add_grid_dimension(int32_t grid_dimension) {
2263     fbb_.AddElement<int32_t>(GPUOperation::VT_GRID_DIMENSION, grid_dimension,
2264                              0);
2265   }
add_work_group_launch_orderGPUOperationBuilder2266   void add_work_group_launch_order(
2267       flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order) {
2268     fbb_.AddOffset(GPUOperation::VT_WORK_GROUP_LAUNCH_ORDER,
2269                    work_group_launch_order);
2270   }
add_grid_sizeGPUOperationBuilder2271   void add_grid_size(flatbuffers::Offset<tflite::gpu::data::Int3> grid_size) {
2272     fbb_.AddOffset(GPUOperation::VT_GRID_SIZE, grid_size);
2273   }
add_src_tensors_namesGPUOperationBuilder2274   void add_src_tensors_names(
2275       flatbuffers::Offset<
2276           flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2277           src_tensors_names) {
2278     fbb_.AddOffset(GPUOperation::VT_SRC_TENSORS_NAMES, src_tensors_names);
2279   }
add_dst_tensors_namesGPUOperationBuilder2280   void add_dst_tensors_names(
2281       flatbuffers::Offset<
2282           flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2283           dst_tensors_names) {
2284     fbb_.AddOffset(GPUOperation::VT_DST_TENSORS_NAMES, dst_tensors_names);
2285   }
add_work_groups_countGPUOperationBuilder2286   void add_work_groups_count(
2287       flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count) {
2288     fbb_.AddOffset(GPUOperation::VT_WORK_GROUPS_COUNT, work_groups_count);
2289   }
add_linkable_countGPUOperationBuilder2290   void add_linkable_count(int32_t linkable_count) {
2291     fbb_.AddElement<int32_t>(GPUOperation::VT_LINKABLE_COUNT, linkable_count,
2292                              0);
2293   }
add_elementwise_codeGPUOperationBuilder2294   void add_elementwise_code(
2295       flatbuffers::Offset<flatbuffers::String> elementwise_code) {
2296     fbb_.AddOffset(GPUOperation::VT_ELEMENTWISE_CODE, elementwise_code);
2297   }
GPUOperationBuilderGPUOperationBuilder2298   explicit GPUOperationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2299       : fbb_(_fbb) {
2300     start_ = fbb_.StartTable();
2301   }
FinishGPUOperationBuilder2302   flatbuffers::Offset<GPUOperation> Finish() {
2303     const auto end = fbb_.EndTable(start_);
2304     auto o = flatbuffers::Offset<GPUOperation>(end);
2305     return o;
2306   }
2307 };
2308 
2309 inline flatbuffers::Offset<GPUOperation> CreateGPUOperation(
2310     flatbuffers::FlatBufferBuilder &_fbb,
2311     flatbuffers::Offset<tflite::gpu::data::Arguments> arguments = 0,
2312     flatbuffers::Offset<flatbuffers::String> code = 0,
2313     flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size = 0,
2314     flatbuffers::Offset<flatbuffers::Vector<
2315         flatbuffers::Offset<tflite::gpu::data::CompilerOption>>>
2316         compiler_options = 0,
2317     tflite::gpu::data::TensorToGrid tensor_to_grid =
2318         tflite::gpu::data::TensorToGrid::CUSTOM,
2319     bool elementwise = false, bool linkable = false,
2320     bool check_src_channels_size = false,
2321     flatbuffers::Offset<tflite::gpu::data::OperationDef> definition = 0,
2322     int32_t grid_dimension = 0,
2323     flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order = 0,
2324     flatbuffers::Offset<tflite::gpu::data::Int3> grid_size = 0,
2325     flatbuffers::Offset<
2326         flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2327         src_tensors_names = 0,
2328     flatbuffers::Offset<
2329         flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2330         dst_tensors_names = 0,
2331     flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count = 0,
2332     int32_t linkable_count = 0,
2333     flatbuffers::Offset<flatbuffers::String> elementwise_code = 0) {
2334   GPUOperationBuilder builder_(_fbb);
2335   builder_.add_elementwise_code(elementwise_code);
2336   builder_.add_linkable_count(linkable_count);
2337   builder_.add_work_groups_count(work_groups_count);
2338   builder_.add_dst_tensors_names(dst_tensors_names);
2339   builder_.add_src_tensors_names(src_tensors_names);
2340   builder_.add_grid_size(grid_size);
2341   builder_.add_work_group_launch_order(work_group_launch_order);
2342   builder_.add_grid_dimension(grid_dimension);
2343   builder_.add_definition(definition);
2344   builder_.add_compiler_options(compiler_options);
2345   builder_.add_work_group_size(work_group_size);
2346   builder_.add_code(code);
2347   builder_.add_arguments(arguments);
2348   builder_.add_check_src_channels_size(check_src_channels_size);
2349   builder_.add_linkable(linkable);
2350   builder_.add_elementwise(elementwise);
2351   builder_.add_tensor_to_grid(tensor_to_grid);
2352   return builder_.Finish();
2353 }
2354 
2355 inline flatbuffers::Offset<GPUOperation> CreateGPUOperationDirect(
2356     flatbuffers::FlatBufferBuilder &_fbb,
2357     flatbuffers::Offset<tflite::gpu::data::Arguments> arguments = 0,
2358     const char *code = nullptr,
2359     flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size = 0,
2360     const std::vector<flatbuffers::Offset<tflite::gpu::data::CompilerOption>>
2361         *compiler_options = nullptr,
2362     tflite::gpu::data::TensorToGrid tensor_to_grid =
2363         tflite::gpu::data::TensorToGrid::CUSTOM,
2364     bool elementwise = false, bool linkable = false,
2365     bool check_src_channels_size = false,
2366     flatbuffers::Offset<tflite::gpu::data::OperationDef> definition = 0,
2367     int32_t grid_dimension = 0,
2368     flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order = 0,
2369     flatbuffers::Offset<tflite::gpu::data::Int3> grid_size = 0,
2370     const std::vector<flatbuffers::Offset<flatbuffers::String>>
2371         *src_tensors_names = nullptr,
2372     const std::vector<flatbuffers::Offset<flatbuffers::String>>
2373         *dst_tensors_names = nullptr,
2374     flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count = 0,
2375     int32_t linkable_count = 0, const char *elementwise_code = nullptr) {
2376   auto code__ = code ? _fbb.CreateString(code) : 0;
2377   auto compiler_options__ =
2378       compiler_options
2379           ? _fbb.CreateVector<
2380                 flatbuffers::Offset<tflite::gpu::data::CompilerOption>>(
2381                 *compiler_options)
2382           : 0;
2383   auto src_tensors_names__ =
2384       src_tensors_names
2385           ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(
2386                 *src_tensors_names)
2387           : 0;
2388   auto dst_tensors_names__ =
2389       dst_tensors_names
2390           ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(
2391                 *dst_tensors_names)
2392           : 0;
2393   auto elementwise_code__ =
2394       elementwise_code ? _fbb.CreateString(elementwise_code) : 0;
2395   return tflite::gpu::data::CreateGPUOperation(
2396       _fbb, arguments, code__, work_group_size, compiler_options__,
2397       tensor_to_grid, elementwise, linkable, check_src_channels_size,
2398       definition, grid_dimension, work_group_launch_order, grid_size,
2399       src_tensors_names__, dst_tensors_names__, work_groups_count,
2400       linkable_count, elementwise_code__);
2401 }
2402 
2403 }  // namespace data
2404 }  // namespace gpu
2405 }  // namespace tflite
2406 
2407 #endif  // FLATBUFFERS_GENERATED_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
2408