Upload vkgraph_generated.h

runtime_mps_poc/schemas/vkgraph_generated.h

@@ -0,0 +1,1421 @@
+// 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_