text: // automatically generated by the FlatBuffers compiler, do not modify
  
  
  #ifndef FLATBUFFERS_GENERATED_WORKGROUPS_TFLITE_GPU_GL_DATA_H_
  #define FLATBUFFERS_GENERATED_WORKGROUPS_TFLITE_GPU_GL_DATA_H_
  
  #include "flatbuffers/flatbuffers.h"
  
  #include "common_generated.h"
  
  namespace tflite {
  namespace gpu {
  namespace gl {
  namespace data {
  
  struct HardcodedWorkgroup;
  
  struct HardcodedWorkgroups;
  
  struct CustomWorkgroups;
  
  struct HardcodedWorkgroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
      VT_SIZE = 4,
      VT_NODE_INDICES = 6
    };
    const Uint3 *size() const {
      return GetPointer<const Uint3 *>(VT_SIZE);
    }
    const flatbuffers::Vector<uint32_t> *node_indices() const {
      return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_NODE_INDICES);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
      return VerifyTableStart(verifier) &&
             VerifyOffset(verifier, VT_SIZE) &&
             verifier.VerifyTable(size()) &&
             VerifyOffset(verifier, VT_NODE_INDICES) &&
             verifier.VerifyVector(node_indices()) &&
             verifier.EndTable();
    }
  };
  
  struct HardcodedWorkgroupBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_size(flatbuffers::Offset<Uint3> size) {
      fbb_.AddOffset(HardcodedWorkgroup::VT_SIZE, size);
    }
    void add_node_indices(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> node_indices) {
      fbb_.AddOffset(HardcodedWorkgroup::VT_NODE_INDICES, node_indices);
    }
    explicit HardcodedWorkgroupBuilder(flatbuffers::FlatBufferBuilder &_fbb)
          : fbb_(_fbb) {
      start_ = fbb_.StartTable();
    }
    HardcodedWorkgroupBuilder &operator=(const HardcodedWorkgroupBuilder &);
    flatbuffers::Offset<HardcodedWorkgroup> Finish() {
      const auto end = fbb_.EndTable(start_);
      auto o = flatbuffers::Offset<HardcodedWorkgroup>(end);
      return o;
    }
  };
  
  inline flatbuffers::Offset<HardcodedWorkgroup> CreateHardcodedWorkgroup(
      flatbuffers::FlatBufferBuilder &_fbb,
      flatbuffers::Offset<Uint3> size = 0,
      flatbuffers::Offset<flatbuffers::Vector<uint32_t>> node_indices = 0) {
    HardcodedWorkgroupBuilder builder_(_fbb);
    builder_.add_node_indices(node_indices);
    builder_.add_size(size);
    return builder_.Finish();
  }
  
  inline flatbuffers::Offset<HardcodedWorkgroup> CreateHardcodedWorkgroupDirect(
      flatbuffers::FlatBufferBuilder &_fbb,
      flatbuffers::Offset<Uint3> size = 0,
      const std::vector<uint32_t> *node_indices = nullptr) {
    auto node_indices__ = node_indices ? _fbb.CreateVector<uint32_t>(*node_indices) : 0;
    return tflite::gpu::gl::data::CreateHardcodedWorkgroup(
        _fbb,
        size,
        node_indices__);
  }
  
  struct HardcodedWorkgroups FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
      VT_GPU_INFO = 4,
      VT_WORKGROUPS = 6
    };
    const flatbuffers::String *gpu_info() const {
      return GetPointer<const flatbuffers::String *>(VT_GPU_INFO);
    }
    const flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroup>> *workgroups() const {
      return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroup>> *>(VT_WORKGROUPS);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
      return VerifyTableStart(verifier) &&
             VerifyOffset(verifier, VT_GPU_INFO) &&
             verifier.VerifyString(gpu_info()) &&
             VerifyOffset(verifier, VT_WORKGROUPS) &&
             verifier.VerifyVector(workgroups()) &&
             verifier.VerifyVectorOfTables(workgroups()) &&
             verifier.EndTable();
    }
  };
  
  struct HardcodedWorkgroupsBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_gpu_info(flatbuffers::Offset<flatbuffers::String> gpu_info) {
      fbb_.AddOffset(HardcodedWorkgroups::VT_GPU_INFO, gpu_info);
    }
    void add_workgroups(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroup>>> workgroups) {
      fbb_.AddOffset(HardcodedWorkgroups::VT_WORKGROUPS, workgroups);
    }
    explicit HardcodedWorkgroupsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
          : fbb_(_fbb) {
      start_ = fbb_.StartTable();
    }
    HardcodedWorkgroupsBuilder &operator=(const HardcodedWorkgroupsBuilder &);
    flatbuffers::Offset<HardcodedWorkgroups> Finish() {
      const auto end = fbb_.EndTable(start_);
      auto o = flatbuffers::Offset<HardcodedWorkgroups>(end);
      return o;
    }
  };
  
  inline flatbuffers::Offset<HardcodedWorkgroups> CreateHardcodedWorkgroups(
      flatbuffers::FlatBufferBuilder &_fbb,
      flatbuffers::Offset<flatbuffers::String> gpu_info = 0,
      flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroup>>> workgroups = 0) {
    HardcodedWorkgroupsBuilder builder_(_fbb);
    builder_.add_workgroups(workgroups);
    builder_.add_gpu_info(gpu_info);
    return builder_.Finish();
  }
  
  inline flatbuffers::Offset<HardcodedWorkgroups> CreateHardcodedWorkgroupsDirect(
      flatbuffers::FlatBufferBuilder &_fbb,
      const char *gpu_info = nullptr,
      const std::vector<flatbuffers::Offset<HardcodedWorkgroup>> *workgroups = nullptr) {
    auto gpu_info__ = gpu_info ? _fbb.CreateString(gpu_info) : 0;
    auto workgroups__ = workgroups ? _fbb.CreateVector<flatbuffers::Offset<HardcodedWorkgroup>>(*workgroups) : 0;
    return tflite::gpu::gl::data::CreateHardcodedWorkgroups(
        _fbb,
        gpu_info__,
        workgroups__);
  }
  
  struct CustomWorkgroups FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
      VT_HARDCODED_WORKGROUPS = 4
    };
    const flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroups>> *hardcoded_workgroups() const {
      return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroups>> *>(VT_HARDCODED_WORKGROUPS);
    }
    bool Verify(flatbuffers::Verifier &verifier) const {
      return VerifyTableStart(verifier) &&
             VerifyOffset(verifier, VT_HARDCODED_WORKGROUPS) &&
             verifier.VerifyVector(hardcoded_workgroups()) &&
             verifier.VerifyVectorOfTables(hardcoded_workgroups()) &&
             verifier.EndTable();
    }
  };
  
  struct CustomWorkgroupsBuilder {
    flatbuffers::FlatBufferBuilder &fbb_;
    flatbuffers::uoffset_t start_;
    void add_hardcoded_workgroups(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroups>>> hardcoded_workgroups) {
      fbb_.AddOffset(CustomWorkgroups::VT_HARDCODED_WORKGROUPS, hardcoded_workgroups);
    }
    explicit CustomWorkgroupsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
          : fbb_(_fbb) {
      start_ = fbb_.StartTable();
    }
    CustomWorkgroupsBuilder &operator=(const CustomWorkgroupsBuilder &);
    flatbuffers::Offset<CustomWorkgroups> Finish() {
      const auto end = fbb_.EndTable(start_);
      auto o = flatbuffers::Offset<CustomWorkgroups>(end);
      return o;
    }
  };
  
  inline flatbuffers::Offset<CustomWorkgroups> CreateCustomWorkgroups(
      flatbuffers::FlatBufferBuilder &_fbb,
      flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HardcodedWorkgroups>>> hardcoded_workgroups = 0) {
    CustomWorkgroupsBuilder builder_(_fbb);
    builder_.add_hardcoded_workgroups(hardcoded_workgroups);
    return builder_.Finish();
  }
  
  inline flatbuffers::Offset<CustomWorkgroups> CreateCustomWorkgroupsDirect(
      flatbuffers::FlatBufferBuilder &_fbb,
      const std::vector<flatbuffers::Offset<HardcodedWorkgroups>> *hardcoded_workgroups = nullptr) {
    auto hardcoded_workgroups__ = hardcoded_workgroups ? _fbb.CreateVector<flatbuffers::Offset<HardcodedWorkgroups>>(*hardcoded_workgroups) : 0;
    return tflite::gpu::gl::data::CreateCustomWorkgroups(
        _fbb,
        hardcoded_workgroups__);
  }
  
  inline const tflite::gpu::gl::data::CustomWorkgroups *GetCustomWorkgroups(const void *buf) {
    return flatbuffers::GetRoot<tflite::gpu::gl::data::CustomWorkgroups>(buf);
  }
  
  inline const tflite::gpu::gl::data::CustomWorkgroups *GetSizePrefixedCustomWorkgroups(const void *buf) {
    return flatbuffers::GetSizePrefixedRoot<tflite::gpu::gl::data::CustomWorkgroups>(buf);
  }
  
  inline const char *CustomWorkgroupsIdentifier() {
    return "AFWS";
  }
  
  inline bool CustomWorkgroupsBufferHasIdentifier(const void *buf) {
    return flatbuffers::BufferHasIdentifier(
        buf, CustomWorkgroupsIdentifier());
  }
  
  inline bool VerifyCustomWorkgroupsBuffer(
      flatbuffers::Verifier &verifier) {
    return verifier.VerifyBuffer<tflite::gpu::gl::data::CustomWorkgroups>(CustomWorkgroupsIdentifier());
  }
  
  inline bool VerifySizePrefixedCustomWorkgroupsBuffer(
      flatbuffers::Verifier &verifier) {
    return verifier.VerifySizePrefixedBuffer<tflite::gpu::gl::data::CustomWorkgroups>(CustomWorkgroupsIdentifier());
  }
  
  inline void FinishCustomWorkgroupsBuffer(
      flatbuffers::FlatBufferBuilder &fbb,
      flatbuffers::Offset<tflite::gpu::gl::data::CustomWorkgroups> root) {
    fbb.Finish(root, CustomWorkgroupsIdentifier());
  }
  
  inline void FinishSizePrefixedCustomWorkgroupsBuffer(
      flatbuffers::FlatBufferBuilder &fbb,
      flatbuffers::Offset<tflite::gpu::gl::data::CustomWorkgroups> root) {
    fbb.FinishSizePrefixed(root, CustomWorkgroupsIdentifier());
  }
  
  }  // namespace data
  }  // namespace gl
  }  // namespace gpu
  }  // namespace tflite
  
  #endif  // FLATBUFFERS_GENERATED_WORKGROUPS_TFLITE_GPU_GL_DATA_H_
  