// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_VKGRAPH_VKGRAPH_H_
#define FLATBUFFERS_GENERATED_VKGRAPH_VKGRAPH_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");

namespace vkgraph {

struct OperatorCall;
struct OperatorCallBuilder;

struct VkTensor;
struct VkTensorBuilder;

struct Null;
struct NullBuilder;

struct Int;
struct IntBuilder;

struct Bool;
struct BoolBuilder;

struct Double;
struct DoubleBuilder;

struct String;
struct StringBuilder;

struct IntList;
struct IntListBuilder;

struct DoubleList;
struct DoubleListBuilder;

struct BoolList;
struct BoolListBuilder;

struct ValueList;
struct ValueListBuilder;

struct SymInt;
struct SymIntBuilder;

struct VkValue;
struct VkValueBuilder;

struct VkBytes;
struct VkBytesBuilder;

struct VkGraph;
struct VkGraphBuilder;

enum VkDataType : int8_t {
  VkDataType_BOOL = 0,
  VkDataType_UINT8 = 1,
  VkDataType_INT8 = 2,
  VkDataType_INT32 = 3,
  VkDataType_FLOAT16 = 4,
  VkDataType_FLOAT32 = 5,
  VkDataType_FLOAT64 = 6,
  VkDataType_INT64 = 7,
  VkDataType_UNSET = 127,
  VkDataType_MIN = VkDataType_BOOL,
  VkDataType_MAX = VkDataType_UNSET
};

inline const VkDataType (&EnumValuesVkDataType())[9] {
  static const VkDataType values[] = {
    VkDataType_BOOL,
    VkDataType_UINT8,
    VkDataType_INT8,
    VkDataType_INT32,
    VkDataType_FLOAT16,
    VkDataType_FLOAT32,
    VkDataType_FLOAT64,
    VkDataType_INT64,
    VkDataType_UNSET
  };
  return values;
}

inline const char *EnumNameVkDataType(VkDataType e) {
  switch (e) {
    case VkDataType_BOOL: return "BOOL";
    case VkDataType_UINT8: return "UINT8";
    case VkDataType_INT8: return "INT8";
    case VkDataType_INT32: return "INT32";
    case VkDataType_FLOAT16: return "FLOAT16";
    case VkDataType_FLOAT32: return "FLOAT32";
    case VkDataType_FLOAT64: return "FLOAT64";
    case VkDataType_INT64: return "INT64";
    case VkDataType_UNSET: return "UNSET";
    default: return "";
  }
}

enum VkStorageType : uint8_t {
  VkStorageType_BUFFER = 0,
  VkStorageType_TEXTURE_3D = 1,
  VkStorageType_TEXTURE_2D = 2,
  VkStorageType_DEFAULT_STORAGE = 255,
  VkStorageType_MIN = VkStorageType_BUFFER,
  VkStorageType_MAX = VkStorageType_DEFAULT_STORAGE
};

inline const VkStorageType (&EnumValuesVkStorageType())[4] {
  static const VkStorageType values[] = {
    VkStorageType_BUFFER,
    VkStorageType_TEXTURE_3D,
    VkStorageType_TEXTURE_2D,
    VkStorageType_DEFAULT_STORAGE
  };
  return values;
}

inline const char *EnumNameVkStorageType(VkStorageType e) {
  switch (e) {
    case VkStorageType_BUFFER: return "BUFFER";
    case VkStorageType_TEXTURE_3D: return "TEXTURE_3D";
    case VkStorageType_TEXTURE_2D: return "TEXTURE_2D";
    case VkStorageType_DEFAULT_STORAGE: return "DEFAULT_STORAGE";
    default: return "";
  }
}

enum VkMemoryLayout : uint8_t {
  VkMemoryLayout_TENSOR_WIDTH_PACKED = 0,
  VkMemoryLayout_TENSOR_HEIGHT_PACKED = 1,
  VkMemoryLayout_TENSOR_CHANNELS_PACKED = 2,
  VkMemoryLayout_PACKED_INT8_4W4C = 3,
  VkMemoryLayout_PACKED_INT8_4H4W = 4,
  VkMemoryLayout_PACKED_INT8_4W = 5,
  VkMemoryLayout_PACKED_INT8_4C = 6,
  VkMemoryLayout_PACKED_INT8_4C1W = 8,
  VkMemoryLayout_PACKED_INT8_CONV2D = 9,
  VkMemoryLayout_DEFAULT_LAYOUT = 255,
  VkMemoryLayout_MIN = VkMemoryLayout_TENSOR_WIDTH_PACKED,
  VkMemoryLayout_MAX = VkMemoryLayout_DEFAULT_LAYOUT
};

inline const VkMemoryLayout (&EnumValuesVkMemoryLayout())[10] {
  static const VkMemoryLayout values[] = {
    VkMemoryLayout_TENSOR_WIDTH_PACKED,
    VkMemoryLayout_TENSOR_HEIGHT_PACKED,
    VkMemoryLayout_TENSOR_CHANNELS_PACKED,
    VkMemoryLayout_PACKED_INT8_4W4C,
    VkMemoryLayout_PACKED_INT8_4H4W,
    VkMemoryLayout_PACKED_INT8_4W,
    VkMemoryLayout_PACKED_INT8_4C,
    VkMemoryLayout_PACKED_INT8_4C1W,
    VkMemoryLayout_PACKED_INT8_CONV2D,
    VkMemoryLayout_DEFAULT_LAYOUT
  };
  return values;
}

inline const char *EnumNameVkMemoryLayout(VkMemoryLayout e) {
  switch (e) {
    case VkMemoryLayout_TENSOR_WIDTH_PACKED: return "TENSOR_WIDTH_PACKED";
    case VkMemoryLayout_TENSOR_HEIGHT_PACKED: return "TENSOR_HEIGHT_PACKED";
    case VkMemoryLayout_TENSOR_CHANNELS_PACKED: return "TENSOR_CHANNELS_PACKED";
    case VkMemoryLayout_PACKED_INT8_4W4C: return "PACKED_INT8_4W4C";
    case VkMemoryLayout_PACKED_INT8_4H4W: return "PACKED_INT8_4H4W";
    case VkMemoryLayout_PACKED_INT8_4W: return "PACKED_INT8_4W";
    case VkMemoryLayout_PACKED_INT8_4C: return "PACKED_INT8_4C";
    case VkMemoryLayout_PACKED_INT8_4C1W: return "PACKED_INT8_4C1W";
    case VkMemoryLayout_PACKED_INT8_CONV2D: return "PACKED_INT8_CONV2D";
    case VkMemoryLayout_DEFAULT_LAYOUT: return "DEFAULT_LAYOUT";
    default: return "";
  }
}

enum GraphTypes : uint8_t {
  GraphTypes_NONE = 0,
  GraphTypes_Null = 1,
  GraphTypes_Int = 2,
  GraphTypes_Double = 3,
  GraphTypes_Bool = 4,
  GraphTypes_VkTensor = 5,
  GraphTypes_IntList = 6,
  GraphTypes_DoubleList = 7,
  GraphTypes_BoolList = 8,
  GraphTypes_ValueList = 9,
  GraphTypes_String = 10,
  GraphTypes_SymInt = 11,
  GraphTypes_MIN = GraphTypes_NONE,
  GraphTypes_MAX = GraphTypes_SymInt
};

inline const GraphTypes (&EnumValuesGraphTypes())[12] {
  static const GraphTypes values[] = {
    GraphTypes_NONE,
    GraphTypes_Null,
    GraphTypes_Int,
    GraphTypes_Double,
    GraphTypes_Bool,
    GraphTypes_VkTensor,
    GraphTypes_IntList,
    GraphTypes_DoubleList,
    GraphTypes_BoolList,
    GraphTypes_ValueList,
    GraphTypes_String,
    GraphTypes_SymInt
  };
  return values;
}

inline const char * const *EnumNamesGraphTypes() {
  static const char * const names[13] = {
    "NONE",
    "Null",
    "Int",
    "Double",
    "Bool",
    "VkTensor",
    "IntList",
    "DoubleList",
    "BoolList",
    "ValueList",
    "String",
    "SymInt",
    nullptr
  };
  return names;
}

inline const char *EnumNameGraphTypes(GraphTypes e) {
  if (::flatbuffers::IsOutRange(e, GraphTypes_NONE, GraphTypes_SymInt)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesGraphTypes()[index];
}

template<typename T> struct GraphTypesTraits {
  static const GraphTypes enum_value = GraphTypes_NONE;
};

template<> struct GraphTypesTraits<vkgraph::Null> {
  static const GraphTypes enum_value = GraphTypes_Null;
};

template<> struct GraphTypesTraits<vkgraph::Int> {
  static const GraphTypes enum_value = GraphTypes_Int;
};

template<> struct GraphTypesTraits<vkgraph::Double> {
  static const GraphTypes enum_value = GraphTypes_Double;
};

template<> struct GraphTypesTraits<vkgraph::Bool> {
  static const GraphTypes enum_value = GraphTypes_Bool;
};

template<> struct GraphTypesTraits<vkgraph::VkTensor> {
  static const GraphTypes enum_value = GraphTypes_VkTensor;
};

template<> struct GraphTypesTraits<vkgraph::IntList> {
  static const GraphTypes enum_value = GraphTypes_IntList;
};

template<> struct GraphTypesTraits<vkgraph::DoubleList> {
  static const GraphTypes enum_value = GraphTypes_DoubleList;
};

template<> struct GraphTypesTraits<vkgraph::BoolList> {
  static const GraphTypes enum_value = GraphTypes_BoolList;
};

template<> struct GraphTypesTraits<vkgraph::ValueList> {
  static const GraphTypes enum_value = GraphTypes_ValueList;
};

template<> struct GraphTypesTraits<vkgraph::String> {
  static const GraphTypes enum_value = GraphTypes_String;
};

template<> struct GraphTypesTraits<vkgraph::SymInt> {
  static const GraphTypes enum_value = GraphTypes_SymInt;
};

bool VerifyGraphTypes(::flatbuffers::Verifier &verifier, const void *obj, GraphTypes type);
bool VerifyGraphTypesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);

struct OperatorCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OperatorCallBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NODE_ID = 4,
    VT_NAME = 6,
    VT_ARGS = 8
  };
  uint32_t node_id() const {
    return GetField<uint32_t>(VT_NODE_ID, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::Vector<int32_t> *args() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_ARGS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_NODE_ID, 4) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_ARGS) &&
           verifier.VerifyVector(args()) &&
           verifier.EndTable();
  }
};

struct OperatorCallBuilder {
  typedef OperatorCall Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_node_id(uint32_t node_id) {
    fbb_.AddElement<uint32_t>(OperatorCall::VT_NODE_ID, node_id, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(OperatorCall::VT_NAME, name);
  }
  void add_args(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> args) {
    fbb_.AddOffset(OperatorCall::VT_ARGS, args);
  }
  explicit OperatorCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<OperatorCall> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<OperatorCall>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<OperatorCall> CreateOperatorCall(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t node_id = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> args = 0) {
  OperatorCallBuilder builder_(_fbb);
  builder_.add_args(args);
  builder_.add_name(name);
  builder_.add_node_id(node_id);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<OperatorCall> CreateOperatorCallDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t node_id = 0,
    const char *name = nullptr,
    const std::vector<int32_t> *args = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto args__ = args ? _fbb.CreateVector<int32_t>(*args) : 0;
  return vkgraph::CreateOperatorCall(
      _fbb,
      node_id,
      name__,
      args__);
}

struct VkTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VkTensorBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATATYPE = 4,
    VT_DIMS = 6,
    VT_CONSTANT_ID = 8,
    VT_MEM_OBJ_ID = 10,
    VT_STORAGE_TYPE = 12,
    VT_MEMORY_LAYOUT = 14,
    VT_STAGING_DATATYPE = 16
  };
  vkgraph::VkDataType datatype() const {
    return static_cast<vkgraph::VkDataType>(GetField<int8_t>(VT_DATATYPE, 0));
  }
  const ::flatbuffers::Vector<uint32_t> *dims() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_DIMS);
  }
  int32_t constant_id() const {
    return GetField<int32_t>(VT_CONSTANT_ID, 0);
  }
  int32_t mem_obj_id() const {
    return GetField<int32_t>(VT_MEM_OBJ_ID, 0);
  }
  vkgraph::VkStorageType storage_type() const {
    return static_cast<vkgraph::VkStorageType>(GetField<uint8_t>(VT_STORAGE_TYPE, 255));
  }
  vkgraph::VkMemoryLayout memory_layout() const {
    return static_cast<vkgraph::VkMemoryLayout>(GetField<uint8_t>(VT_MEMORY_LAYOUT, 255));
  }
  vkgraph::VkDataType staging_datatype() const {
    return static_cast<vkgraph::VkDataType>(GetField<int8_t>(VT_STAGING_DATATYPE, 127));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_DATATYPE, 1) &&
           VerifyOffset(verifier, VT_DIMS) &&
           verifier.VerifyVector(dims()) &&
           VerifyField<int32_t>(verifier, VT_CONSTANT_ID, 4) &&
           VerifyField<int32_t>(verifier, VT_MEM_OBJ_ID, 4) &&
           VerifyField<uint8_t>(verifier, VT_STORAGE_TYPE, 1) &&
           VerifyField<uint8_t>(verifier, VT_MEMORY_LAYOUT, 1) &&
           VerifyField<int8_t>(verifier, VT_STAGING_DATATYPE, 1) &&
           verifier.EndTable();
  }
};

struct VkTensorBuilder {
  typedef VkTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_datatype(vkgraph::VkDataType datatype) {
    fbb_.AddElement<int8_t>(VkTensor::VT_DATATYPE, static_cast<int8_t>(datatype), 0);
  }
  void add_dims(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> dims) {
    fbb_.AddOffset(VkTensor::VT_DIMS, dims);
  }
  void add_constant_id(int32_t constant_id) {
    fbb_.AddElement<int32_t>(VkTensor::VT_CONSTANT_ID, constant_id, 0);
  }
  void add_mem_obj_id(int32_t mem_obj_id) {
    fbb_.AddElement<int32_t>(VkTensor::VT_MEM_OBJ_ID, mem_obj_id, 0);
  }
  void add_storage_type(vkgraph::VkStorageType storage_type) {
    fbb_.AddElement<uint8_t>(VkTensor::VT_STORAGE_TYPE, static_cast<uint8_t>(storage_type), 255);
  }
  void add_memory_layout(vkgraph::VkMemoryLayout memory_layout) {
    fbb_.AddElement<uint8_t>(VkTensor::VT_MEMORY_LAYOUT, static_cast<uint8_t>(memory_layout), 255);
  }
  void add_staging_datatype(vkgraph::VkDataType staging_datatype) {
    fbb_.AddElement<int8_t>(VkTensor::VT_STAGING_DATATYPE, static_cast<int8_t>(staging_datatype), 127);
  }
  explicit VkTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VkTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VkTensor>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VkTensor> CreateVkTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    vkgraph::VkDataType datatype = vkgraph::VkDataType_BOOL,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> dims = 0,
    int32_t constant_id = 0,
    int32_t mem_obj_id = 0,
    vkgraph::VkStorageType storage_type = vkgraph::VkStorageType_DEFAULT_STORAGE,
    vkgraph::VkMemoryLayout memory_layout = vkgraph::VkMemoryLayout_DEFAULT_LAYOUT,
    vkgraph::VkDataType staging_datatype = vkgraph::VkDataType_UNSET) {
  VkTensorBuilder builder_(_fbb);
  builder_.add_mem_obj_id(mem_obj_id);
  builder_.add_constant_id(constant_id);
  builder_.add_dims(dims);
  builder_.add_staging_datatype(staging_datatype);
  builder_.add_memory_layout(memory_layout);
  builder_.add_storage_type(storage_type);
  builder_.add_datatype(datatype);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VkTensor> CreateVkTensorDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    vkgraph::VkDataType datatype = vkgraph::VkDataType_BOOL,
    const std::vector<uint32_t> *dims = nullptr,
    int32_t constant_id = 0,
    int32_t mem_obj_id = 0,
    vkgraph::VkStorageType storage_type = vkgraph::VkStorageType_DEFAULT_STORAGE,
    vkgraph::VkMemoryLayout memory_layout = vkgraph::VkMemoryLayout_DEFAULT_LAYOUT,
    vkgraph::VkDataType staging_datatype = vkgraph::VkDataType_UNSET) {
  auto dims__ = dims ? _fbb.CreateVector<uint32_t>(*dims) : 0;
  return vkgraph::CreateVkTensor(
      _fbb,
      datatype,
      dims__,
      constant_id,
      mem_obj_id,
      storage_type,
      memory_layout,
      staging_datatype);
}

struct Null FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NullBuilder Builder;
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct NullBuilder {
  typedef Null Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit NullBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Null> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Null>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Null> CreateNull(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  NullBuilder builder_(_fbb);
  return builder_.Finish();
}

struct Int FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IntBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INT_VAL = 4
  };
  int64_t int_val() const {
    return GetField<int64_t>(VT_INT_VAL, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_INT_VAL, 8) &&
           verifier.EndTable();
  }
};

struct IntBuilder {
  typedef Int Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_int_val(int64_t int_val) {
    fbb_.AddElement<int64_t>(Int::VT_INT_VAL, int_val, 0);
  }
  explicit IntBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Int> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Int>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Int> CreateInt(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int64_t int_val = 0) {
  IntBuilder builder_(_fbb);
  builder_.add_int_val(int_val);
  return builder_.Finish();
}

struct Bool FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BoolBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOOL_VAL = 4
  };
  bool bool_val() const {
    return GetField<uint8_t>(VT_BOOL_VAL, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_BOOL_VAL, 1) &&
           verifier.EndTable();
  }
};

struct BoolBuilder {
  typedef Bool Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_bool_val(bool bool_val) {
    fbb_.AddElement<uint8_t>(Bool::VT_BOOL_VAL, static_cast<uint8_t>(bool_val), 0);
  }
  explicit BoolBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Bool> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Bool>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Bool> CreateBool(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    bool bool_val = false) {
  BoolBuilder builder_(_fbb);
  builder_.add_bool_val(bool_val);
  return builder_.Finish();
}

struct Double FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DoubleBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DOUBLE_VAL = 4
  };
  double double_val() const {
    return GetField<double>(VT_DOUBLE_VAL, 0.0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, VT_DOUBLE_VAL, 8) &&
           verifier.EndTable();
  }
};

struct DoubleBuilder {
  typedef Double Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_double_val(double double_val) {
    fbb_.AddElement<double>(Double::VT_DOUBLE_VAL, double_val, 0.0);
  }
  explicit DoubleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Double> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Double>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Double> CreateDouble(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    double double_val = 0.0) {
  DoubleBuilder builder_(_fbb);
  builder_.add_double_val(double_val);
  return builder_.Finish();
}

struct String FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef StringBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STRING_VAL = 4
  };
  const ::flatbuffers::String *string_val() const {
    return GetPointer<const ::flatbuffers::String *>(VT_STRING_VAL);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_STRING_VAL) &&
           verifier.VerifyString(string_val()) &&
           verifier.EndTable();
  }
};

struct StringBuilder {
  typedef String Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_string_val(::flatbuffers::Offset<::flatbuffers::String> string_val) {
    fbb_.AddOffset(String::VT_STRING_VAL, string_val);
  }
  explicit StringBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<String> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<String>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<String> CreateString(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> string_val = 0) {
  StringBuilder builder_(_fbb);
  builder_.add_string_val(string_val);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<String> CreateStringDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *string_val = nullptr) {
  auto string_val__ = string_val ? _fbb.CreateString(string_val) : 0;
  return vkgraph::CreateString(
      _fbb,
      string_val__);
}

struct IntList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IntListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ITEMS = 4
  };
  const ::flatbuffers::Vector<int64_t> *items() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ITEMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.EndTable();
  }
};

struct IntListBuilder {
  typedef IntList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> items) {
    fbb_.AddOffset(IntList::VT_ITEMS, items);
  }
  explicit IntListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<IntList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<IntList>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<IntList> CreateIntList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> items = 0) {
  IntListBuilder builder_(_fbb);
  builder_.add_items(items);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<IntList> CreateIntListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *items = nullptr) {
  auto items__ = items ? _fbb.CreateVector<int64_t>(*items) : 0;
  return vkgraph::CreateIntList(
      _fbb,
      items__);
}

struct DoubleList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DoubleListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ITEMS = 4
  };
  const ::flatbuffers::Vector<double> *items() const {
    return GetPointer<const ::flatbuffers::Vector<double> *>(VT_ITEMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.EndTable();
  }
};

struct DoubleListBuilder {
  typedef DoubleList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<double>> items) {
    fbb_.AddOffset(DoubleList::VT_ITEMS, items);
  }
  explicit DoubleListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DoubleList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DoubleList>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DoubleList> CreateDoubleList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<double>> items = 0) {
  DoubleListBuilder builder_(_fbb);
  builder_.add_items(items);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<DoubleList> CreateDoubleListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<double> *items = nullptr) {
  auto items__ = items ? _fbb.CreateVector<double>(*items) : 0;
  return vkgraph::CreateDoubleList(
      _fbb,
      items__);
}

struct BoolList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BoolListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ITEMS = 4
  };
  const ::flatbuffers::Vector<uint8_t> *items() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ITEMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.EndTable();
  }
};

struct BoolListBuilder {
  typedef BoolList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> items) {
    fbb_.AddOffset(BoolList::VT_ITEMS, items);
  }
  explicit BoolListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BoolList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BoolList>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<BoolList> CreateBoolList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> items = 0) {
  BoolListBuilder builder_(_fbb);
  builder_.add_items(items);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<BoolList> CreateBoolListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *items = nullptr) {
  auto items__ = items ? _fbb.CreateVector<uint8_t>(*items) : 0;
  return vkgraph::CreateBoolList(
      _fbb,
      items__);
}

struct ValueList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ValueListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ITEMS = 4
  };
  const ::flatbuffers::Vector<int32_t> *items() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_ITEMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ITEMS) &&
           verifier.VerifyVector(items()) &&
           verifier.EndTable();
  }
};

struct ValueListBuilder {
  typedef ValueList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_items(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> items) {
    fbb_.AddOffset(ValueList::VT_ITEMS, items);
  }
  explicit ValueListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ValueList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ValueList>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ValueList> CreateValueList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> items = 0) {
  ValueListBuilder builder_(_fbb);
  builder_.add_items(items);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<ValueList> CreateValueListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *items = nullptr) {
  auto items__ = items ? _fbb.CreateVector<int32_t>(*items) : 0;
  return vkgraph::CreateValueList(
      _fbb,
      items__);
}

struct SymInt FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SymIntBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUE = 4
  };
  int32_t value() const {
    return GetField<int32_t>(VT_VALUE, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
           verifier.EndTable();
  }
};

struct SymIntBuilder {
  typedef SymInt Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_value(int32_t value) {
    fbb_.AddElement<int32_t>(SymInt::VT_VALUE, value, 0);
  }
  explicit SymIntBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SymInt> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SymInt>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SymInt> CreateSymInt(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t value = 0) {
  SymIntBuilder builder_(_fbb);
  builder_.add_value(value);
  return builder_.Finish();
}

struct VkValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VkValueBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VALUE_TYPE = 4,
    VT_VALUE = 6
  };
  vkgraph::GraphTypes value_type() const {
    return static_cast<vkgraph::GraphTypes>(GetField<uint8_t>(VT_VALUE_TYPE, 0));
  }
  const void *value() const {
    return GetPointer<const void *>(VT_VALUE);
  }
  template<typename T> const T *value_as() const;
  const vkgraph::Null *value_as_Null() const {
    return value_type() == vkgraph::GraphTypes_Null ? static_cast<const vkgraph::Null *>(value()) : nullptr;
  }
  const vkgraph::Int *value_as_Int() const {
    return value_type() == vkgraph::GraphTypes_Int ? static_cast<const vkgraph::Int *>(value()) : nullptr;
  }
  const vkgraph::Double *value_as_Double() const {
    return value_type() == vkgraph::GraphTypes_Double ? static_cast<const vkgraph::Double *>(value()) : nullptr;
  }
  const vkgraph::Bool *value_as_Bool() const {
    return value_type() == vkgraph::GraphTypes_Bool ? static_cast<const vkgraph::Bool *>(value()) : nullptr;
  }
  const vkgraph::VkTensor *value_as_VkTensor() const {
    return value_type() == vkgraph::GraphTypes_VkTensor ? static_cast<const vkgraph::VkTensor *>(value()) : nullptr;
  }
  const vkgraph::IntList *value_as_IntList() const {
    return value_type() == vkgraph::GraphTypes_IntList ? static_cast<const vkgraph::IntList *>(value()) : nullptr;
  }
  const vkgraph::DoubleList *value_as_DoubleList() const {
    return value_type() == vkgraph::GraphTypes_DoubleList ? static_cast<const vkgraph::DoubleList *>(value()) : nullptr;
  }
  const vkgraph::BoolList *value_as_BoolList() const {
    return value_type() == vkgraph::GraphTypes_BoolList ? static_cast<const vkgraph::BoolList *>(value()) : nullptr;
  }
  const vkgraph::ValueList *value_as_ValueList() const {
    return value_type() == vkgraph::GraphTypes_ValueList ? static_cast<const vkgraph::ValueList *>(value()) : nullptr;
  }
  const vkgraph::String *value_as_String() const {
    return value_type() == vkgraph::GraphTypes_String ? static_cast<const vkgraph::String *>(value()) : nullptr;
  }
  const vkgraph::SymInt *value_as_SymInt() const {
    return value_type() == vkgraph::GraphTypes_SymInt ? static_cast<const vkgraph::SymInt *>(value()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_VALUE_TYPE, 1) &&
           VerifyOffset(verifier, VT_VALUE) &&
           VerifyGraphTypes(verifier, value(), value_type()) &&
           verifier.EndTable();
  }
};

template<> inline const vkgraph::Null *VkValue::value_as<vkgraph::Null>() const {
  return value_as_Null();
}

template<> inline const vkgraph::Int *VkValue::value_as<vkgraph::Int>() const {
  return value_as_Int();
}

template<> inline const vkgraph::Double *VkValue::value_as<vkgraph::Double>() const {
  return value_as_Double();
}

template<> inline const vkgraph::Bool *VkValue::value_as<vkgraph::Bool>() const {
  return value_as_Bool();
}

template<> inline const vkgraph::VkTensor *VkValue::value_as<vkgraph::VkTensor>() const {
  return value_as_VkTensor();
}

template<> inline const vkgraph::IntList *VkValue::value_as<vkgraph::IntList>() const {
  return value_as_IntList();
}

template<> inline const vkgraph::DoubleList *VkValue::value_as<vkgraph::DoubleList>() const {
  return value_as_DoubleList();
}

template<> inline const vkgraph::BoolList *VkValue::value_as<vkgraph::BoolList>() const {
  return value_as_BoolList();
}

template<> inline const vkgraph::ValueList *VkValue::value_as<vkgraph::ValueList>() const {
  return value_as_ValueList();
}

template<> inline const vkgraph::String *VkValue::value_as<vkgraph::String>() const {
  return value_as_String();
}

template<> inline const vkgraph::SymInt *VkValue::value_as<vkgraph::SymInt>() const {
  return value_as_SymInt();
}

struct VkValueBuilder {
  typedef VkValue Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_value_type(vkgraph::GraphTypes value_type) {
    fbb_.AddElement<uint8_t>(VkValue::VT_VALUE_TYPE, static_cast<uint8_t>(value_type), 0);
  }
  void add_value(::flatbuffers::Offset<void> value) {
    fbb_.AddOffset(VkValue::VT_VALUE, value);
  }
  explicit VkValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VkValue> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VkValue>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VkValue> CreateVkValue(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    vkgraph::GraphTypes value_type = vkgraph::GraphTypes_NONE,
    ::flatbuffers::Offset<void> value = 0) {
  VkValueBuilder builder_(_fbb);
  builder_.add_value(value);
  builder_.add_value_type(value_type);
  return builder_.Finish();
}

struct VkBytes FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VkBytesBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OFFSET = 4,
    VT_LENGTH = 6,
    VT_NAMED_KEY = 8
  };
  uint64_t offset() const {
    return GetField<uint64_t>(VT_OFFSET, 0);
  }
  uint64_t length() const {
    return GetField<uint64_t>(VT_LENGTH, 0);
  }
  const ::flatbuffers::String *named_key() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAMED_KEY);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_OFFSET, 8) &&
           VerifyField<uint64_t>(verifier, VT_LENGTH, 8) &&
           VerifyOffset(verifier, VT_NAMED_KEY) &&
           verifier.VerifyString(named_key()) &&
           verifier.EndTable();
  }
};

struct VkBytesBuilder {
  typedef VkBytes Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_offset(uint64_t offset) {
    fbb_.AddElement<uint64_t>(VkBytes::VT_OFFSET, offset, 0);
  }
  void add_length(uint64_t length) {
    fbb_.AddElement<uint64_t>(VkBytes::VT_LENGTH, length, 0);
  }
  void add_named_key(::flatbuffers::Offset<::flatbuffers::String> named_key) {
    fbb_.AddOffset(VkBytes::VT_NAMED_KEY, named_key);
  }
  explicit VkBytesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VkBytes> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VkBytes>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VkBytes> CreateVkBytes(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t offset = 0,
    uint64_t length = 0,
    ::flatbuffers::Offset<::flatbuffers::String> named_key = 0) {
  VkBytesBuilder builder_(_fbb);
  builder_.add_length(length);
  builder_.add_offset(offset);
  builder_.add_named_key(named_key);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VkBytes> CreateVkBytesDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t offset = 0,
    uint64_t length = 0,
    const char *named_key = nullptr) {
  auto named_key__ = named_key ? _fbb.CreateString(named_key) : 0;
  return vkgraph::CreateVkBytes(
      _fbb,
      offset,
      length,
      named_key__);
}

struct VkGraph FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef VkGraphBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VERSION = 4,
    VT_CHAIN = 6,
    VT_VALUES = 8,
    VT_INPUT_IDS = 10,
    VT_OUTPUT_IDS = 12,
    VT_CONSTANTS = 14,
    VT_SHADERS = 16,
    VT_STORAGE_TYPE_OVERRIDE = 18,
    VT_MEMORY_LAYOUT_OVERRIDE = 20
  };
  const ::flatbuffers::String *version() const {
    return GetPointer<const ::flatbuffers::String *>(VT_VERSION);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::OperatorCall>> *chain() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::OperatorCall>> *>(VT_CHAIN);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkValue>> *values() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkValue>> *>(VT_VALUES);
  }
  const ::flatbuffers::Vector<uint32_t> *input_ids() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_INPUT_IDS);
  }
  const ::flatbuffers::Vector<uint32_t> *output_ids() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_OUTPUT_IDS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>> *constants() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>> *>(VT_CONSTANTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>> *shaders() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>> *>(VT_SHADERS);
  }
  vkgraph::VkStorageType storage_type_override() const {
    return static_cast<vkgraph::VkStorageType>(GetField<uint8_t>(VT_STORAGE_TYPE_OVERRIDE, 255));
  }
  vkgraph::VkMemoryLayout memory_layout_override() const {
    return static_cast<vkgraph::VkMemoryLayout>(GetField<uint8_t>(VT_MEMORY_LAYOUT_OVERRIDE, 255));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_VERSION) &&
           verifier.VerifyString(version()) &&
           VerifyOffset(verifier, VT_CHAIN) &&
           verifier.VerifyVector(chain()) &&
           verifier.VerifyVectorOfTables(chain()) &&
           VerifyOffset(verifier, VT_VALUES) &&
           verifier.VerifyVector(values()) &&
           verifier.VerifyVectorOfTables(values()) &&
           VerifyOffset(verifier, VT_INPUT_IDS) &&
           verifier.VerifyVector(input_ids()) &&
           VerifyOffset(verifier, VT_OUTPUT_IDS) &&
           verifier.VerifyVector(output_ids()) &&
           VerifyOffset(verifier, VT_CONSTANTS) &&
           verifier.VerifyVector(constants()) &&
           verifier.VerifyVectorOfTables(constants()) &&
           VerifyOffset(verifier, VT_SHADERS) &&
           verifier.VerifyVector(shaders()) &&
           verifier.VerifyVectorOfTables(shaders()) &&
           VerifyField<uint8_t>(verifier, VT_STORAGE_TYPE_OVERRIDE, 1) &&
           VerifyField<uint8_t>(verifier, VT_MEMORY_LAYOUT_OVERRIDE, 1) &&
           verifier.EndTable();
  }
};

struct VkGraphBuilder {
  typedef VkGraph Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_version(::flatbuffers::Offset<::flatbuffers::String> version) {
    fbb_.AddOffset(VkGraph::VT_VERSION, version);
  }
  void add_chain(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::OperatorCall>>> chain) {
    fbb_.AddOffset(VkGraph::VT_CHAIN, chain);
  }
  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkValue>>> values) {
    fbb_.AddOffset(VkGraph::VT_VALUES, values);
  }
  void add_input_ids(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> input_ids) {
    fbb_.AddOffset(VkGraph::VT_INPUT_IDS, input_ids);
  }
  void add_output_ids(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> output_ids) {
    fbb_.AddOffset(VkGraph::VT_OUTPUT_IDS, output_ids);
  }
  void add_constants(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>>> constants) {
    fbb_.AddOffset(VkGraph::VT_CONSTANTS, constants);
  }
  void add_shaders(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>>> shaders) {
    fbb_.AddOffset(VkGraph::VT_SHADERS, shaders);
  }
  void add_storage_type_override(vkgraph::VkStorageType storage_type_override) {
    fbb_.AddElement<uint8_t>(VkGraph::VT_STORAGE_TYPE_OVERRIDE, static_cast<uint8_t>(storage_type_override), 255);
  }
  void add_memory_layout_override(vkgraph::VkMemoryLayout memory_layout_override) {
    fbb_.AddElement<uint8_t>(VkGraph::VT_MEMORY_LAYOUT_OVERRIDE, static_cast<uint8_t>(memory_layout_override), 255);
  }
  explicit VkGraphBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<VkGraph> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<VkGraph>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<VkGraph> CreateVkGraph(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> version = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::OperatorCall>>> chain = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkValue>>> values = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> input_ids = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> output_ids = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>>> constants = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<vkgraph::VkBytes>>> shaders = 0,
    vkgraph::VkStorageType storage_type_override = vkgraph::VkStorageType_DEFAULT_STORAGE,
    vkgraph::VkMemoryLayout memory_layout_override = vkgraph::VkMemoryLayout_DEFAULT_LAYOUT) {
  VkGraphBuilder builder_(_fbb);
  builder_.add_shaders(shaders);
  builder_.add_constants(constants);
  builder_.add_output_ids(output_ids);
  builder_.add_input_ids(input_ids);
  builder_.add_values(values);
  builder_.add_chain(chain);
  builder_.add_version(version);
  builder_.add_memory_layout_override(memory_layout_override);
  builder_.add_storage_type_override(storage_type_override);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<VkGraph> CreateVkGraphDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *version = nullptr,
    const std::vector<::flatbuffers::Offset<vkgraph::OperatorCall>> *chain = nullptr,
    const std::vector<::flatbuffers::Offset<vkgraph::VkValue>> *values = nullptr,
    const std::vector<uint32_t> *input_ids = nullptr,
    const std::vector<uint32_t> *output_ids = nullptr,
    const std::vector<::flatbuffers::Offset<vkgraph::VkBytes>> *constants = nullptr,
    const std::vector<::flatbuffers::Offset<vkgraph::VkBytes>> *shaders = nullptr,
    vkgraph::VkStorageType storage_type_override = vkgraph::VkStorageType_DEFAULT_STORAGE,
    vkgraph::VkMemoryLayout memory_layout_override = vkgraph::VkMemoryLayout_DEFAULT_LAYOUT) {
  auto version__ = version ? _fbb.CreateString(version) : 0;
  auto chain__ = chain ? _fbb.CreateVector<::flatbuffers::Offset<vkgraph::OperatorCall>>(*chain) : 0;
  auto values__ = values ? _fbb.CreateVector<::flatbuffers::Offset<vkgraph::VkValue>>(*values) : 0;
  auto input_ids__ = input_ids ? _fbb.CreateVector<uint32_t>(*input_ids) : 0;
  auto output_ids__ = output_ids ? _fbb.CreateVector<uint32_t>(*output_ids) : 0;
  auto constants__ = constants ? _fbb.CreateVector<::flatbuffers::Offset<vkgraph::VkBytes>>(*constants) : 0;
  auto shaders__ = shaders ? _fbb.CreateVector<::flatbuffers::Offset<vkgraph::VkBytes>>(*shaders) : 0;
  return vkgraph::CreateVkGraph(
      _fbb,
      version__,
      chain__,
      values__,
      input_ids__,
      output_ids__,
      constants__,
      shaders__,
      storage_type_override,
      memory_layout_override);
}

inline bool VerifyGraphTypes(::flatbuffers::Verifier &verifier, const void *obj, GraphTypes type) {
  switch (type) {
    case GraphTypes_NONE: {
      return true;
    }
    case GraphTypes_Null: {
      auto ptr = reinterpret_cast<const vkgraph::Null *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_Int: {
      auto ptr = reinterpret_cast<const vkgraph::Int *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_Double: {
      auto ptr = reinterpret_cast<const vkgraph::Double *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_Bool: {
      auto ptr = reinterpret_cast<const vkgraph::Bool *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_VkTensor: {
      auto ptr = reinterpret_cast<const vkgraph::VkTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_IntList: {
      auto ptr = reinterpret_cast<const vkgraph::IntList *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_DoubleList: {
      auto ptr = reinterpret_cast<const vkgraph::DoubleList *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_BoolList: {
      auto ptr = reinterpret_cast<const vkgraph::BoolList *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_ValueList: {
      auto ptr = reinterpret_cast<const vkgraph::ValueList *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_String: {
      auto ptr = reinterpret_cast<const vkgraph::String *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case GraphTypes_SymInt: {
      auto ptr = reinterpret_cast<const vkgraph::SymInt *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyGraphTypesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyGraphTypes(
        verifier,  values->Get(i), types->GetEnum<GraphTypes>(i))) {
      return false;
    }
  }
  return true;
}

inline const vkgraph::VkGraph *GetVkGraph(const void *buf) {
  return ::flatbuffers::GetRoot<vkgraph::VkGraph>(buf);
}

inline const vkgraph::VkGraph *GetSizePrefixedVkGraph(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<vkgraph::VkGraph>(buf);
}

inline const char *VkGraphIdentifier() {
  return "VK00";
}

inline bool VkGraphBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, VkGraphIdentifier());
}

inline bool SizePrefixedVkGraphBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, VkGraphIdentifier(), true);
}

inline bool VerifyVkGraphBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<vkgraph::VkGraph>(VkGraphIdentifier());
}

inline bool VerifySizePrefixedVkGraphBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<vkgraph::VkGraph>(VkGraphIdentifier());
}

inline void FinishVkGraphBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<vkgraph::VkGraph> root) {
  fbb.Finish(root, VkGraphIdentifier());
}

inline void FinishSizePrefixedVkGraphBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<vkgraph::VkGraph> root) {
  fbb.FinishSizePrefixed(root, VkGraphIdentifier());
}

}  // namespace vkgraph

#endif  // FLATBUFFERS_GENERATED_VKGRAPH_VKGRAPH_H_