binary_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_BINARY_TT_TARGET_METAL_H_
#define FLATBUFFERS_GENERATED_BINARY_TT_TARGET_METAL_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");
 
#include "ttmlir/Target/Common/debug_info_generated.h"
#include "ttmlir/Target/Common/types_generated.h"
#include "ttmlir/Target/Common/version_generated.h"
#include "ttmlir/Target/TTMetal/command_generated.h"
#include "ttmlir/Target/TTMetal/types_generated.h"
 
// For access to the binary schema that produced this file.
#include "binary_bfbs_generated.h"
 
namespace tt {
namespace target {
namespace metal {
 
struct MemoryDesc;
struct MemoryDescBuilder;
 
struct LayoutDesc;
struct LayoutDescBuilder;
 
struct TensorDesc;
struct TensorDescBuilder;
 
struct TensorRef;
struct TensorRefBuilder;
 
struct DeviceProgram;
struct DeviceProgramBuilder;
 
struct Program;
struct ProgramBuilder;
 
struct TTMetalBinary;
struct TTMetalBinaryBuilder;
 
struct MemoryDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryDescBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.MemoryDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA_TYPE = 4
  };
  tt::target::DataType data_type() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DATA_TYPE, 0));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_DATA_TYPE, 2) &&
           verifier.EndTable();
  }
};
 
struct MemoryDescBuilder {
  typedef MemoryDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_data_type(tt::target::DataType data_type) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_DATA_TYPE, static_cast<uint16_t>(data_type), 0);
  }
  explicit MemoryDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryDesc> CreateMemoryDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::DataType data_type = tt::target::DataType::Float32) {
  MemoryDescBuilder builder_(_fbb);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}
 
struct MemoryDesc::Traits {
  using type = MemoryDesc;
  static auto constexpr Create = CreateMemoryDesc;
};
 
struct LayoutDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LayoutDescBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.LayoutDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MEMORY_DESC = 4
  };
  const tt::target::metal::MemoryDesc *memory_desc() const {
    return GetPointer<const tt::target::metal::MemoryDesc *>(VT_MEMORY_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_MEMORY_DESC) &&
           verifier.VerifyTable(memory_desc()) &&
           verifier.EndTable();
  }
};
 
struct LayoutDescBuilder {
  typedef LayoutDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_memory_desc(::flatbuffers::Offset<tt::target::metal::MemoryDesc> memory_desc) {
    fbb_.AddOffset(LayoutDesc::VT_MEMORY_DESC, memory_desc);
  }
  explicit LayoutDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LayoutDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LayoutDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LayoutDesc> CreateLayoutDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::MemoryDesc> memory_desc = 0) {
  LayoutDescBuilder builder_(_fbb);
  builder_.add_memory_desc(memory_desc);
  return builder_.Finish();
}
 
struct LayoutDesc::Traits {
  using type = LayoutDesc;
  static auto constexpr Create = CreateLayoutDesc;
};
 
struct TensorDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorDescBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.TensorDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_MESH_SHAPE = 6,
    VT_LAYOUT = 8
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const ::flatbuffers::Vector<int32_t> *mesh_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_MESH_SHAPE);
  }
  const tt::target::metal::LayoutDesc *layout() const {
    return GetPointer<const tt::target::metal::LayoutDesc *>(VT_LAYOUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_MESH_SHAPE) &&
           verifier.VerifyVector(mesh_shape()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyTable(layout()) &&
           verifier.EndTable();
  }
};
 
struct TensorDescBuilder {
  typedef TensorDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(TensorDesc::VT_SHAPE, shape);
  }
  void add_mesh_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> mesh_shape) {
    fbb_.AddOffset(TensorDesc::VT_MESH_SHAPE, mesh_shape);
  }
  void add_layout(::flatbuffers::Offset<tt::target::metal::LayoutDesc> layout) {
    fbb_.AddOffset(TensorDesc::VT_LAYOUT, layout);
  }
  explicit TensorDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> mesh_shape = 0,
    ::flatbuffers::Offset<tt::target::metal::LayoutDesc> layout = 0) {
  TensorDescBuilder builder_(_fbb);
  builder_.add_layout(layout);
  builder_.add_mesh_shape(mesh_shape);
  builder_.add_shape(shape);
  return builder_.Finish();
}
 
struct TensorDesc::Traits {
  using type = TensorDesc;
  static auto constexpr Create = CreateTensorDesc;
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    const std::vector<int32_t> *mesh_shape = nullptr,
    ::flatbuffers::Offset<tt::target::metal::LayoutDesc> layout = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto mesh_shape__ = mesh_shape ? _fbb.CreateVector<int32_t>(*mesh_shape) : 0;
  return tt::target::metal::CreateTensorDesc(
      _fbb,
      shape__,
      mesh_shape__,
      layout);
}
 
struct TensorRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorRefBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.TensorRef";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SIZE = 4,
    VT_DESC = 6
  };
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  const tt::target::metal::TensorDesc *desc() const {
    return GetPointer<const tt::target::metal::TensorDesc *>(VT_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           VerifyOffset(verifier, VT_DESC) &&
           verifier.VerifyTable(desc()) &&
           verifier.EndTable();
  }
};
 
struct TensorRefBuilder {
  typedef TensorRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(TensorRef::VT_SIZE, size, 0);
  }
  void add_desc(::flatbuffers::Offset<tt::target::metal::TensorDesc> desc) {
    fbb_.AddOffset(TensorRef::VT_DESC, desc);
  }
  explicit TensorRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorRef> CreateTensorRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t size = 0,
    ::flatbuffers::Offset<tt::target::metal::TensorDesc> desc = 0) {
  TensorRefBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_desc(desc);
  return builder_.Finish();
}
 
struct TensorRef::Traits {
  using type = TensorRef;
  static auto constexpr Create = CreateTensorRef;
};
 
struct DeviceProgram FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DeviceProgramBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.DeviceProgram";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUTS = 4,
    VT_OUTPUTS = 6,
    VT_COMMAND_QUEUES = 8
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *>(VT_OUTPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CommandQueue>> *command_queues() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CommandQueue>> *>(VT_COMMAND_QUEUES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           verifier.VerifyVectorOfTables(outputs()) &&
           VerifyOffset(verifier, VT_COMMAND_QUEUES) &&
           verifier.VerifyVector(command_queues()) &&
           verifier.VerifyVectorOfTables(command_queues()) &&
           verifier.EndTable();
  }
};
 
struct DeviceProgramBuilder {
  typedef DeviceProgram Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> inputs) {
    fbb_.AddOffset(DeviceProgram::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> outputs) {
    fbb_.AddOffset(DeviceProgram::VT_OUTPUTS, outputs);
  }
  void add_command_queues(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CommandQueue>>> command_queues) {
    fbb_.AddOffset(DeviceProgram::VT_COMMAND_QUEUES, command_queues);
  }
  explicit DeviceProgramBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DeviceProgram> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DeviceProgram>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DeviceProgram> CreateDeviceProgram(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::BufferRef>>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::CommandQueue>>> command_queues = 0) {
  DeviceProgramBuilder builder_(_fbb);
  builder_.add_command_queues(command_queues);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  return builder_.Finish();
}
 
struct DeviceProgram::Traits {
  using type = DeviceProgram;
  static auto constexpr Create = CreateDeviceProgram;
};
 
inline ::flatbuffers::Offset<DeviceProgram> CreateDeviceProgramDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::BufferRef>> *outputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::CommandQueue>> *command_queues = nullptr) {
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::BufferRef>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::BufferRef>>(*outputs) : 0;
  auto command_queues__ = command_queues ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::CommandQueue>>(*command_queues) : 0;
  return tt::target::metal::CreateDeviceProgram(
      _fbb,
      inputs__,
      outputs__,
      command_queues__);
}
 
struct Program FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ProgramBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.Program";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_INPUTS = 6,
    VT_OUTPUTS = 8,
    VT_DEVICE_PROGRAMS = 10,
    VT_DEBUG_INFO = 12
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *>(VT_OUTPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>> *device_programs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>> *>(VT_DEVICE_PROGRAMS);
  }
  const tt::target::DebugInfo *debug_info() const {
    return GetPointer<const tt::target::DebugInfo *>(VT_DEBUG_INFO);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           verifier.VerifyVectorOfTables(outputs()) &&
           VerifyOffset(verifier, VT_DEVICE_PROGRAMS) &&
           verifier.VerifyVector(device_programs()) &&
           verifier.VerifyVectorOfTables(device_programs()) &&
           VerifyOffset(verifier, VT_DEBUG_INFO) &&
           verifier.VerifyTable(debug_info()) &&
           verifier.EndTable();
  }
};
 
struct ProgramBuilder {
  typedef Program Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Program::VT_NAME, name);
  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>>> inputs) {
    fbb_.AddOffset(Program::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>>> outputs) {
    fbb_.AddOffset(Program::VT_OUTPUTS, outputs);
  }
  void add_device_programs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>>> device_programs) {
    fbb_.AddOffset(Program::VT_DEVICE_PROGRAMS, device_programs);
  }
  void add_debug_info(::flatbuffers::Offset<tt::target::DebugInfo> debug_info) {
    fbb_.AddOffset(Program::VT_DEBUG_INFO, debug_info);
  }
  explicit ProgramBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Program> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Program>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Program> CreateProgram(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::TensorRef>>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>>> device_programs = 0,
    ::flatbuffers::Offset<tt::target::DebugInfo> debug_info = 0) {
  ProgramBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  builder_.add_device_programs(device_programs);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  builder_.add_name(name);
  return builder_.Finish();
}
 
struct Program::Traits {
  using type = Program;
  static auto constexpr Create = CreateProgram;
};
 
inline ::flatbuffers::Offset<Program> CreateProgramDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::TensorRef>> *outputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>> *device_programs = nullptr,
    ::flatbuffers::Offset<tt::target::DebugInfo> debug_info = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::TensorRef>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::TensorRef>>(*outputs) : 0;
  auto device_programs__ = device_programs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::DeviceProgram>>(*device_programs) : 0;
  return tt::target::metal::CreateProgram(
      _fbb,
      name__,
      inputs__,
      outputs__,
      device_programs__,
      debug_info);
}
 
struct TTMetalBinary FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TTMetalBinaryBuilder Builder;
  typedef tt::target::metal::TTMetalBinaryBinarySchema BinarySchema;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.TTMetalBinary";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_VERSION = 4,
    VT_TTMLIR_GIT_HASH = 6,
    VT_SYSTEM_DESC = 8,
    VT_PROGRAMS = 10
  };
  const tt::target::Version *version() const {
    return GetStruct<const tt::target::Version *>(VT_VERSION);
  }
  const ::flatbuffers::String *ttmlir_git_hash() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TTMLIR_GIT_HASH);
  }
  const tt::target::SystemDesc *system_desc() const {
    return GetPointer<const tt::target::SystemDesc *>(VT_SYSTEM_DESC);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Program>> *programs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Program>> *>(VT_PROGRAMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::Version>(verifier, VT_VERSION, 4) &&
           VerifyOffset(verifier, VT_TTMLIR_GIT_HASH) &&
           verifier.VerifyString(ttmlir_git_hash()) &&
           VerifyOffset(verifier, VT_SYSTEM_DESC) &&
           verifier.VerifyTable(system_desc()) &&
           VerifyOffset(verifier, VT_PROGRAMS) &&
           verifier.VerifyVector(programs()) &&
           verifier.VerifyVectorOfTables(programs()) &&
           verifier.EndTable();
  }
};
 
struct TTMetalBinaryBuilder {
  typedef TTMetalBinary Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_version(const tt::target::Version *version) {
    fbb_.AddStruct(TTMetalBinary::VT_VERSION, version);
  }
  void add_ttmlir_git_hash(::flatbuffers::Offset<::flatbuffers::String> ttmlir_git_hash) {
    fbb_.AddOffset(TTMetalBinary::VT_TTMLIR_GIT_HASH, ttmlir_git_hash);
  }
  void add_system_desc(::flatbuffers::Offset<tt::target::SystemDesc> system_desc) {
    fbb_.AddOffset(TTMetalBinary::VT_SYSTEM_DESC, system_desc);
  }
  void add_programs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Program>>> programs) {
    fbb_.AddOffset(TTMetalBinary::VT_PROGRAMS, programs);
  }
  explicit TTMetalBinaryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TTMetalBinary> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TTMetalBinary>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TTMetalBinary> CreateTTMetalBinary(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Version *version = nullptr,
    ::flatbuffers::Offset<::flatbuffers::String> ttmlir_git_hash = 0,
    ::flatbuffers::Offset<tt::target::SystemDesc> system_desc = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::metal::Program>>> programs = 0) {
  TTMetalBinaryBuilder builder_(_fbb);
  builder_.add_programs(programs);
  builder_.add_system_desc(system_desc);
  builder_.add_ttmlir_git_hash(ttmlir_git_hash);
  builder_.add_version(version);
  return builder_.Finish();
}
 
struct TTMetalBinary::Traits {
  using type = TTMetalBinary;
  static auto constexpr Create = CreateTTMetalBinary;
};
 
inline ::flatbuffers::Offset<TTMetalBinary> CreateTTMetalBinaryDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Version *version = nullptr,
    const char *ttmlir_git_hash = nullptr,
    ::flatbuffers::Offset<tt::target::SystemDesc> system_desc = 0,
    const std::vector<::flatbuffers::Offset<tt::target::metal::Program>> *programs = nullptr) {
  auto ttmlir_git_hash__ = ttmlir_git_hash ? _fbb.CreateString(ttmlir_git_hash) : 0;
  auto programs__ = programs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::metal::Program>>(*programs) : 0;
  return tt::target::metal::CreateTTMetalBinary(
      _fbb,
      version,
      ttmlir_git_hash__,
      system_desc,
      programs__);
}
 
inline const tt::target::metal::TTMetalBinary *GetTTMetalBinary(const void *buf) {
  return ::flatbuffers::GetRoot<tt::target::metal::TTMetalBinary>(buf);
}
 
inline const tt::target::metal::TTMetalBinary *GetSizePrefixedTTMetalBinary(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<tt::target::metal::TTMetalBinary>(buf);
}
 
inline const char *TTMetalBinaryIdentifier() {
  return "TTM0";
}
 
inline bool TTMetalBinaryBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, TTMetalBinaryIdentifier());
}
 
inline bool SizePrefixedTTMetalBinaryBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, TTMetalBinaryIdentifier(), true);
}
 
inline bool VerifyTTMetalBinaryBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<tt::target::metal::TTMetalBinary>(TTMetalBinaryIdentifier());
}
 
inline bool VerifySizePrefixedTTMetalBinaryBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<tt::target::metal::TTMetalBinary>(TTMetalBinaryIdentifier());
}
 
inline const char *TTMetalBinaryExtension() {
  return "ttm";
}
 
inline void FinishTTMetalBinaryBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tt::target::metal::TTMetalBinary> root) {
  fbb.Finish(root, TTMetalBinaryIdentifier());
}
 
inline void FinishSizePrefixedTTMetalBinaryBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<tt::target::metal::TTMetalBinary> root) {
  fbb.FinishSizePrefixed(root, TTMetalBinaryIdentifier());
}
 
}  // namespace metal
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_BINARY_TT_TARGET_METAL_H_