program_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_PROGRAM_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_PROGRAM_TT_TARGET_TTNN_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 "debug_info_generated.h"
#include "types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct GetDeviceOp;
struct GetDeviceOpBuilder;
 
struct ToMemoryConfigOp;
struct ToMemoryConfigOpBuilder;
 
struct ToLayoutOp;
struct ToLayoutOpBuilder;
 
struct ToDeviceOp;
struct ToDeviceOpBuilder;
 
struct FromDeviceOp;
struct FromDeviceOpBuilder;
 
struct EmptyOp;
struct EmptyOpBuilder;
 
struct FullOp;
struct FullOpBuilder;
 
struct EltwiseOp;
struct EltwiseOpBuilder;
 
struct ReductionOp;
struct ReductionOpBuilder;
 
struct EmbeddingOp;
struct EmbeddingOpBuilder;
 
struct SoftmaxOp;
struct SoftmaxOpBuilder;
 
struct TransposeOp;
struct TransposeOpBuilder;
 
struct ConcatOp;
struct ConcatOpBuilder;
 
struct ReshapeOp;
struct ReshapeOpBuilder;
 
struct MatmulOp;
struct MatmulOpBuilder;
 
struct Conv2dOp;
struct Conv2dOpBuilder;
 
struct MaxPool2dOp;
struct MaxPool2dOpBuilder;
 
struct DeallocOp;
struct DeallocOpBuilder;
 
struct Operation;
struct OperationBuilder;
 
struct Program;
struct ProgramBuilder;
 
enum class EltwiseOpType : uint32_t {
  Add = 0,
  Multiply = 1,
  Subtract = 2,
  Relu = 3,
  GreaterEqual = 4,
  Sqrt = 5,
  Div = 6,
  Sigmoid = 7,
  Reciprocal = 8,
  Exp = 9,
  Maximum = 10,
  Abs = 11,
  Neg = 12,
  MIN = Add,
  MAX = Neg
};
 
inline const EltwiseOpType (&EnumValuesEltwiseOpType())[13] {
  static const EltwiseOpType values[] = {
    EltwiseOpType::Add,
    EltwiseOpType::Multiply,
    EltwiseOpType::Subtract,
    EltwiseOpType::Relu,
    EltwiseOpType::GreaterEqual,
    EltwiseOpType::Sqrt,
    EltwiseOpType::Div,
    EltwiseOpType::Sigmoid,
    EltwiseOpType::Reciprocal,
    EltwiseOpType::Exp,
    EltwiseOpType::Maximum,
    EltwiseOpType::Abs,
    EltwiseOpType::Neg
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseOpType() {
  static const char * const names[14] = {
    "Add",
    "Multiply",
    "Subtract",
    "Relu",
    "GreaterEqual",
    "Sqrt",
    "Div",
    "Sigmoid",
    "Reciprocal",
    "Exp",
    "Maximum",
    "Abs",
    "Neg",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseOpType(EltwiseOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseOpType::Add, EltwiseOpType::Neg)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseOpType()[index];
}
 
enum class ReductionOpType : uint32_t {
  Sum = 0,
  Mean = 1,
  Max = 2,
  MIN = Sum,
  MAX = Max
};
 
inline const ReductionOpType (&EnumValuesReductionOpType())[3] {
  static const ReductionOpType values[] = {
    ReductionOpType::Sum,
    ReductionOpType::Mean,
    ReductionOpType::Max
  };
  return values;
}
 
inline const char * const *EnumNamesReductionOpType() {
  static const char * const names[4] = {
    "Sum",
    "Mean",
    "Max",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameReductionOpType(ReductionOpType e) {
  if (::flatbuffers::IsOutRange(e, ReductionOpType::Sum, ReductionOpType::Max)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesReductionOpType()[index];
}
 
enum class OpType : uint8_t {
  NONE = 0,
  GetDeviceOp = 1,
  ToMemoryConfigOp = 2,
  ToLayoutOp = 3,
  ToDeviceOp = 4,
  FromDeviceOp = 5,
  EmptyOp = 6,
  FullOp = 7,
  EltwiseOp = 8,
  MatmulOp = 9,
  ReductionOp = 10,
  EmbeddingOp = 11,
  SoftmaxOp = 12,
  TransposeOp = 13,
  Conv2dOp = 14,
  ConcatOp = 15,
  ReshapeOp = 16,
  MaxPool2dOp = 17,
  DeallocOp = 18,
  MIN = NONE,
  MAX = DeallocOp
};
 
inline const OpType (&EnumValuesOpType())[19] {
  static const OpType values[] = {
    OpType::NONE,
    OpType::GetDeviceOp,
    OpType::ToMemoryConfigOp,
    OpType::ToLayoutOp,
    OpType::ToDeviceOp,
    OpType::FromDeviceOp,
    OpType::EmptyOp,
    OpType::FullOp,
    OpType::EltwiseOp,
    OpType::MatmulOp,
    OpType::ReductionOp,
    OpType::EmbeddingOp,
    OpType::SoftmaxOp,
    OpType::TransposeOp,
    OpType::Conv2dOp,
    OpType::ConcatOp,
    OpType::ReshapeOp,
    OpType::MaxPool2dOp,
    OpType::DeallocOp
  };
  return values;
}
 
inline const char * const *EnumNamesOpType() {
  static const char * const names[20] = {
    "NONE",
    "GetDeviceOp",
    "ToMemoryConfigOp",
    "ToLayoutOp",
    "ToDeviceOp",
    "FromDeviceOp",
    "EmptyOp",
    "FullOp",
    "EltwiseOp",
    "MatmulOp",
    "ReductionOp",
    "EmbeddingOp",
    "SoftmaxOp",
    "TransposeOp",
    "Conv2dOp",
    "ConcatOp",
    "ReshapeOp",
    "MaxPool2dOp",
    "DeallocOp",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameOpType(OpType e) {
  if (::flatbuffers::IsOutRange(e, OpType::NONE, OpType::DeallocOp)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesOpType()[index];
}
 
template<typename T> struct OpTypeTraits {
  static const OpType enum_value = OpType::NONE;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::GetDeviceOp> {
  static const OpType enum_value = OpType::GetDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToMemoryConfigOp> {
  static const OpType enum_value = OpType::ToMemoryConfigOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToLayoutOp> {
  static const OpType enum_value = OpType::ToLayoutOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToDeviceOp> {
  static const OpType enum_value = OpType::ToDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FromDeviceOp> {
  static const OpType enum_value = OpType::FromDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EmptyOp> {
  static const OpType enum_value = OpType::EmptyOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FullOp> {
  static const OpType enum_value = OpType::FullOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseOp> {
  static const OpType enum_value = OpType::EltwiseOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::MatmulOp> {
  static const OpType enum_value = OpType::MatmulOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReductionOp> {
  static const OpType enum_value = OpType::ReductionOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EmbeddingOp> {
  static const OpType enum_value = OpType::EmbeddingOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::SoftmaxOp> {
  static const OpType enum_value = OpType::SoftmaxOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::TransposeOp> {
  static const OpType enum_value = OpType::TransposeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::Conv2dOp> {
  static const OpType enum_value = OpType::Conv2dOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ConcatOp> {
  static const OpType enum_value = OpType::ConcatOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReshapeOp> {
  static const OpType enum_value = OpType::ReshapeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::MaxPool2dOp> {
  static const OpType enum_value = OpType::MaxPool2dOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::DeallocOp> {
  static const OpType enum_value = OpType::DeallocOp;
};
 
bool VerifyOpType(::flatbuffers::Verifier &verifier, const void *obj, OpType type);
bool VerifyOpTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<OpType> *types);
 
struct GetDeviceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef GetDeviceOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MESH = 4,
    VT_CHIP_IDS = 6,
    VT_OUT = 8
  };
  const tt::target::Dim2d *mesh() const {
    return GetStruct<const tt::target::Dim2d *>(VT_MESH);
  }
  const ::flatbuffers::Vector<uint32_t> *chip_ids() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CHIP_IDS);
  }
  const tt::target::DeviceRef *out() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_MESH, 4) &&
           VerifyOffset(verifier, VT_CHIP_IDS) &&
           verifier.VerifyVector(chip_ids()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct GetDeviceOpBuilder {
  typedef GetDeviceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_mesh(const tt::target::Dim2d *mesh) {
    fbb_.AddStruct(GetDeviceOp::VT_MESH, mesh);
  }
  void add_chip_ids(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> chip_ids) {
    fbb_.AddOffset(GetDeviceOp::VT_CHIP_IDS, chip_ids);
  }
  void add_out(::flatbuffers::Offset<tt::target::DeviceRef> out) {
    fbb_.AddOffset(GetDeviceOp::VT_OUT, out);
  }
  explicit GetDeviceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<GetDeviceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<GetDeviceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<GetDeviceOp> CreateGetDeviceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Dim2d *mesh = nullptr,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> chip_ids = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> out = 0) {
  GetDeviceOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_chip_ids(chip_ids);
  builder_.add_mesh(mesh);
  return builder_.Finish();
}
 
struct GetDeviceOp::Traits {
  using type = GetDeviceOp;
  static auto constexpr Create = CreateGetDeviceOp;
};
 
inline ::flatbuffers::Offset<GetDeviceOp> CreateGetDeviceOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Dim2d *mesh = nullptr,
    const std::vector<uint32_t> *chip_ids = nullptr,
    ::flatbuffers::Offset<tt::target::DeviceRef> out = 0) {
  auto chip_ids__ = chip_ids ? _fbb.CreateVector<uint32_t>(*chip_ids) : 0;
  return tt::target::ttnn::CreateGetDeviceOp(
      _fbb,
      mesh,
      chip_ids__,
      out);
}
 
struct ToMemoryConfigOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToMemoryConfigOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN0 = 4,
    VT_DEVICE = 6,
    VT_OUT = 8
  };
  const tt::target::TensorRef *in0() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN0);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN0) &&
           verifier.VerifyTable(in0()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToMemoryConfigOpBuilder {
  typedef ToMemoryConfigOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in0(::flatbuffers::Offset<tt::target::TensorRef> in0) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_IN0, in0);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_DEVICE, device);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_OUT, out);
  }
  explicit ToMemoryConfigOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToMemoryConfigOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToMemoryConfigOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToMemoryConfigOp> CreateToMemoryConfigOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in0 = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  ToMemoryConfigOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_device(device);
  builder_.add_in0(in0);
  return builder_.Finish();
}
 
struct ToMemoryConfigOp::Traits {
  using type = ToMemoryConfigOp;
  static auto constexpr Create = CreateToMemoryConfigOp;
};
 
struct ToLayoutOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToLayoutOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_LAYOUT = 6,
    VT_DEVICE = 8,
    VT_OUT = 10
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  tt::target::TensorLayout layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_LAYOUT, 0));
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToLayoutOpBuilder {
  typedef ToLayoutOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(ToLayoutOp::VT_IN, in);
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(ToLayoutOp::VT_LAYOUT, static_cast<uint16_t>(layout), 0);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ToLayoutOp::VT_DEVICE, device);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ToLayoutOp::VT_OUT, out);
  }
  explicit ToLayoutOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToLayoutOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToLayoutOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToLayoutOp> CreateToLayoutOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  ToLayoutOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_device(device);
  builder_.add_in(in);
  builder_.add_layout(layout);
  return builder_.Finish();
}
 
struct ToLayoutOp::Traits {
  using type = ToLayoutOp;
  static auto constexpr Create = CreateToLayoutOp;
};
 
struct ToDeviceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToDeviceOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_DEVICE = 6,
    VT_MEMCFG = 8,
    VT_OUT = 10
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::MemoryConfigDesc *memcfg() const {
    return GetPointer<const tt::target::MemoryConfigDesc *>(VT_MEMCFG);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToDeviceOpBuilder {
  typedef ToDeviceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(ToDeviceOp::VT_IN, in);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ToDeviceOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(ToDeviceOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ToDeviceOp::VT_OUT, out);
  }
  explicit ToDeviceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToDeviceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToDeviceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToDeviceOp> CreateToDeviceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  ToDeviceOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct ToDeviceOp::Traits {
  using type = ToDeviceOp;
  static auto constexpr Create = CreateToDeviceOp;
};
 
struct FromDeviceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FromDeviceOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct FromDeviceOpBuilder {
  typedef FromDeviceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(FromDeviceOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(FromDeviceOp::VT_OUT, out);
  }
  explicit FromDeviceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FromDeviceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FromDeviceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FromDeviceOp> CreateFromDeviceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  FromDeviceOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct FromDeviceOp::Traits {
  using type = FromDeviceOp;
  static auto constexpr Create = CreateFromDeviceOp;
};
 
struct EmptyOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmptyOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_DTYPE = 6,
    VT_LAYOUT = 8,
    VT_DEVICE = 10,
    VT_MEMCFG = 12,
    VT_OUT = 14
  };
  const ::flatbuffers::Vector<int64_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHAPE);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  tt::target::TensorLayout layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_LAYOUT, 0));
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::MemoryConfigDesc *memcfg() const {
    return GetPointer<const tt::target::MemoryConfigDesc *>(VT_MEMCFG);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EmptyOpBuilder {
  typedef EmptyOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(EmptyOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(EmptyOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(EmptyOp::VT_LAYOUT, static_cast<uint16_t>(layout), 0);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(EmptyOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(EmptyOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(EmptyOp::VT_OUT, out);
  }
  explicit EmptyOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmptyOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmptyOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmptyOp> CreateEmptyOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  EmptyOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_shape(shape);
  builder_.add_layout(layout);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct EmptyOp::Traits {
  using type = EmptyOp;
  static auto constexpr Create = CreateEmptyOp;
};
 
inline ::flatbuffers::Offset<EmptyOp> CreateEmptyOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *shape = nullptr,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateEmptyOp(
      _fbb,
      shape__,
      dtype,
      layout,
      device,
      memcfg,
      out);
}
 
struct FullOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FullOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DEVICE = 4,
    VT_FILL_VALUE = 6,
    VT_OUT = 8
  };
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  float fill_value() const {
    return GetField<float>(VT_FILL_VALUE, 0.0f);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<float>(verifier, VT_FILL_VALUE, 4) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct FullOpBuilder {
  typedef FullOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(FullOp::VT_DEVICE, device);
  }
  void add_fill_value(float fill_value) {
    fbb_.AddElement<float>(FullOp::VT_FILL_VALUE, fill_value, 0.0f);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(FullOp::VT_OUT, out);
  }
  explicit FullOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FullOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FullOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FullOp> CreateFullOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    float fill_value = 0.0f,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  FullOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_fill_value(fill_value);
  builder_.add_device(device);
  return builder_.Finish();
}
 
struct FullOp::Traits {
  using type = FullOp;
  static auto constexpr Create = CreateFullOp;
};
 
struct EltwiseOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_INS = 6,
    VT_OUT = 8
  };
  tt::target::ttnn::EltwiseOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *ins() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *>(VT_INS);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_INS) &&
           verifier.VerifyVector(ins()) &&
           verifier.VerifyVectorOfTables(ins()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EltwiseOpBuilder {
  typedef EltwiseOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_ins(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> ins) {
    fbb_.AddOffset(EltwiseOp::VT_INS, ins);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(EltwiseOp::VT_OUT, out);
  }
  explicit EltwiseOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseOp> CreateEltwiseOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseOpType type = tt::target::ttnn::EltwiseOpType::Add,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> ins = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  EltwiseOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_ins(ins);
  builder_.add_type(type);
  return builder_.Finish();
}
 
struct EltwiseOp::Traits {
  using type = EltwiseOp;
  static auto constexpr Create = CreateEltwiseOp;
};
 
inline ::flatbuffers::Offset<EltwiseOp> CreateEltwiseOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseOpType type = tt::target::ttnn::EltwiseOpType::Add,
    const std::vector<::flatbuffers::Offset<tt::target::TensorRef>> *ins = nullptr,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  auto ins__ = ins ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::TensorRef>>(*ins) : 0;
  return tt::target::ttnn::CreateEltwiseOp(
      _fbb,
      type,
      ins__,
      out);
}
 
struct ReductionOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReductionOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_IN = 6,
    VT_OUT = 8,
    VT_DIM_ARG = 10,
    VT_KEEP_DIM = 12
  };
  tt::target::ttnn::ReductionOpType type() const {
    return static_cast<tt::target::ttnn::ReductionOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<int32_t> *dim_arg() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DIM_ARG);
  }
  bool keep_dim() const {
    return GetField<uint8_t>(VT_KEEP_DIM, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DIM_ARG) &&
           verifier.VerifyVector(dim_arg()) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_DIM, 1) &&
           verifier.EndTable();
  }
};
 
struct ReductionOpBuilder {
  typedef ReductionOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::ReductionOpType type) {
    fbb_.AddElement<uint32_t>(ReductionOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(ReductionOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ReductionOp::VT_OUT, out);
  }
  void add_dim_arg(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dim_arg) {
    fbb_.AddOffset(ReductionOp::VT_DIM_ARG, dim_arg);
  }
  void add_keep_dim(bool keep_dim) {
    fbb_.AddElement<uint8_t>(ReductionOp::VT_KEEP_DIM, static_cast<uint8_t>(keep_dim), 0);
  }
  explicit ReductionOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReductionOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReductionOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReductionOp> CreateReductionOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::ReductionOpType type = tt::target::ttnn::ReductionOpType::Sum,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dim_arg = 0,
    bool keep_dim = false) {
  ReductionOpBuilder builder_(_fbb);
  builder_.add_dim_arg(dim_arg);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_type(type);
  builder_.add_keep_dim(keep_dim);
  return builder_.Finish();
}
 
struct ReductionOp::Traits {
  using type = ReductionOp;
  static auto constexpr Create = CreateReductionOp;
};
 
inline ::flatbuffers::Offset<ReductionOp> CreateReductionOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::ReductionOpType type = tt::target::ttnn::ReductionOpType::Sum,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    const std::vector<int32_t> *dim_arg = nullptr,
    bool keep_dim = false) {
  auto dim_arg__ = dim_arg ? _fbb.CreateVector<int32_t>(*dim_arg) : 0;
  return tt::target::ttnn::CreateReductionOp(
      _fbb,
      type,
      in,
      out,
      dim_arg__,
      keep_dim);
}
 
struct EmbeddingOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmbeddingOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_OUTPUT = 8
  };
  const tt::target::TensorRef *input() const {
    return GetPointer<const tt::target::TensorRef *>(VT_INPUT);
  }
  const tt::target::TensorRef *weight() const {
    return GetPointer<const tt::target::TensorRef *>(VT_WEIGHT);
  }
  const tt::target::TensorRef *output() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUTPUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_OUTPUT) &&
           verifier.VerifyTable(output()) &&
           verifier.EndTable();
  }
};
 
struct EmbeddingOpBuilder {
  typedef EmbeddingOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(EmbeddingOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::TensorRef> weight) {
    fbb_.AddOffset(EmbeddingOp::VT_WEIGHT, weight);
  }
  void add_output(::flatbuffers::Offset<tt::target::TensorRef> output) {
    fbb_.AddOffset(EmbeddingOp::VT_OUTPUT, output);
  }
  explicit EmbeddingOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmbeddingOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmbeddingOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmbeddingOp> CreateEmbeddingOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> output = 0) {
  EmbeddingOpBuilder builder_(_fbb);
  builder_.add_output(output);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct EmbeddingOp::Traits {
  using type = EmbeddingOp;
  static auto constexpr Create = CreateEmbeddingOp;
};
 
struct SoftmaxOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SoftmaxOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DIMENSION = 8
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  int32_t dimension() const {
    return GetField<int32_t>(VT_DIMENSION, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIMENSION, 4) &&
           verifier.EndTable();
  }
};
 
struct SoftmaxOpBuilder {
  typedef SoftmaxOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(SoftmaxOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(SoftmaxOp::VT_OUT, out);
  }
  void add_dimension(int32_t dimension) {
    fbb_.AddElement<int32_t>(SoftmaxOp::VT_DIMENSION, dimension, 0);
  }
  explicit SoftmaxOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SoftmaxOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SoftmaxOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<SoftmaxOp> CreateSoftmaxOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    int32_t dimension = 0) {
  SoftmaxOpBuilder builder_(_fbb);
  builder_.add_dimension(dimension);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct SoftmaxOp::Traits {
  using type = SoftmaxOp;
  static auto constexpr Create = CreateSoftmaxOp;
};
 
struct TransposeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TransposeOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DIM0 = 8,
    VT_DIM1 = 10
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  int32_t dim0() const {
    return GetField<int32_t>(VT_DIM0, 0);
  }
  int32_t dim1() const {
    return GetField<int32_t>(VT_DIM1, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIM0, 4) &&
           VerifyField<int32_t>(verifier, VT_DIM1, 4) &&
           verifier.EndTable();
  }
};
 
struct TransposeOpBuilder {
  typedef TransposeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(TransposeOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(TransposeOp::VT_OUT, out);
  }
  void add_dim0(int32_t dim0) {
    fbb_.AddElement<int32_t>(TransposeOp::VT_DIM0, dim0, 0);
  }
  void add_dim1(int32_t dim1) {
    fbb_.AddElement<int32_t>(TransposeOp::VT_DIM1, dim1, 0);
  }
  explicit TransposeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TransposeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TransposeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TransposeOp> CreateTransposeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    int32_t dim0 = 0,
    int32_t dim1 = 0) {
  TransposeOpBuilder builder_(_fbb);
  builder_.add_dim1(dim1);
  builder_.add_dim0(dim0);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct TransposeOp::Traits {
  using type = TransposeOp;
  static auto constexpr Create = CreateTransposeOp;
};
 
struct ConcatOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConcatOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUTS = 4,
    VT_OUT = 6,
    VT_DIM = 8
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *>(VT_INPUTS);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  int32_t dim() const {
    return GetField<int32_t>(VT_DIM, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIM, 4) &&
           verifier.EndTable();
  }
};
 
struct ConcatOpBuilder {
  typedef ConcatOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> inputs) {
    fbb_.AddOffset(ConcatOp::VT_INPUTS, inputs);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ConcatOp::VT_OUT, out);
  }
  void add_dim(int32_t dim) {
    fbb_.AddElement<int32_t>(ConcatOp::VT_DIM, dim, 0);
  }
  explicit ConcatOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConcatOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConcatOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConcatOp> CreateConcatOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    int32_t dim = 0) {
  ConcatOpBuilder builder_(_fbb);
  builder_.add_dim(dim);
  builder_.add_out(out);
  builder_.add_inputs(inputs);
  return builder_.Finish();
}
 
struct ConcatOp::Traits {
  using type = ConcatOp;
  static auto constexpr Create = CreateConcatOp;
};
 
inline ::flatbuffers::Offset<ConcatOp> CreateConcatOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::TensorRef>> *inputs = nullptr,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    int32_t dim = 0) {
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::TensorRef>>(*inputs) : 0;
  return tt::target::ttnn::CreateConcatOp(
      _fbb,
      inputs__,
      out,
      dim);
}
 
struct ReshapeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReshapeOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_SHAPE = 8
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           verifier.EndTable();
  }
};
 
struct ReshapeOpBuilder {
  typedef ReshapeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(ReshapeOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ReshapeOp::VT_OUT, out);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(ReshapeOp::VT_SHAPE, shape);
  }
  explicit ReshapeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReshapeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReshapeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReshapeOp> CreateReshapeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0) {
  ReshapeOpBuilder builder_(_fbb);
  builder_.add_shape(shape);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct ReshapeOp::Traits {
  using type = ReshapeOp;
  static auto constexpr Create = CreateReshapeOp;
};
 
inline ::flatbuffers::Offset<ReshapeOp> CreateReshapeOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    const std::vector<int32_t> *shape = nullptr) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tt::target::ttnn::CreateReshapeOp(
      _fbb,
      in,
      out,
      shape__);
}
 
struct MatmulOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN0 = 4,
    VT_IN1 = 6,
    VT_OUT = 8
  };
  const tt::target::TensorRef *in0() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN0);
  }
  const tt::target::TensorRef *in1() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN1);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN0) &&
           verifier.VerifyTable(in0()) &&
           VerifyOffset(verifier, VT_IN1) &&
           verifier.VerifyTable(in1()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct MatmulOpBuilder {
  typedef MatmulOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in0(::flatbuffers::Offset<tt::target::TensorRef> in0) {
    fbb_.AddOffset(MatmulOp::VT_IN0, in0);
  }
  void add_in1(::flatbuffers::Offset<tt::target::TensorRef> in1) {
    fbb_.AddOffset(MatmulOp::VT_IN1, in1);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(MatmulOp::VT_OUT, out);
  }
  explicit MatmulOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulOp> CreateMatmulOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in0 = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> in1 = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  MatmulOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in1(in1);
  builder_.add_in0(in0);
  return builder_.Finish();
}
 
struct MatmulOp::Traits {
  using type = MatmulOp;
  static auto constexpr Create = CreateMatmulOp;
};
 
struct Conv2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Conv2dOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_BIAS = 8,
    VT_OUT = 10,
    VT_DEVICE = 12,
    VT_IN_CHANNELS = 14,
    VT_OUT_CHANNELS = 16,
    VT_BATCH_SIZE = 18,
    VT_INPUT_HEIGHT = 20,
    VT_INPUT_WIDTH = 22,
    VT_KERNEL_HEIGHT = 24,
    VT_KERNEL_WIDTH = 26,
    VT_STRIDE_HEIGHT = 28,
    VT_STRIDE_WIDTH = 30,
    VT_PADDING_HEIGHT = 32,
    VT_PADDING_WIDTH = 34,
    VT_DILATION_HEIGHT = 36,
    VT_DILATION_WIDTH = 38,
    VT_GROUPS = 40
  };
  const tt::target::TensorRef *input() const {
    return GetPointer<const tt::target::TensorRef *>(VT_INPUT);
  }
  const tt::target::TensorRef *weight() const {
    return GetPointer<const tt::target::TensorRef *>(VT_WEIGHT);
  }
  const tt::target::TensorRef *bias() const {
    return GetPointer<const tt::target::TensorRef *>(VT_BIAS);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  uint32_t in_channels() const {
    return GetField<uint32_t>(VT_IN_CHANNELS, 0);
  }
  uint32_t out_channels() const {
    return GetField<uint32_t>(VT_OUT_CHANNELS, 0);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  uint32_t kernel_height() const {
    return GetField<uint32_t>(VT_KERNEL_HEIGHT, 0);
  }
  uint32_t kernel_width() const {
    return GetField<uint32_t>(VT_KERNEL_WIDTH, 0);
  }
  uint32_t stride_height() const {
    return GetField<uint32_t>(VT_STRIDE_HEIGHT, 0);
  }
  uint32_t stride_width() const {
    return GetField<uint32_t>(VT_STRIDE_WIDTH, 0);
  }
  uint32_t padding_height() const {
    return GetField<uint32_t>(VT_PADDING_HEIGHT, 0);
  }
  uint32_t padding_width() const {
    return GetField<uint32_t>(VT_PADDING_WIDTH, 0);
  }
  uint32_t dilation_height() const {
    return GetField<uint32_t>(VT_DILATION_HEIGHT, 0);
  }
  uint32_t dilation_width() const {
    return GetField<uint32_t>(VT_DILATION_WIDTH, 0);
  }
  uint32_t groups() const {
    return GetField<uint32_t>(VT_GROUPS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_BIAS) &&
           verifier.VerifyTable(bias()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_IN_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_OUT_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_KERNEL_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_KERNEL_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_STRIDE_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_STRIDE_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_PADDING_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_PADDING_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_DILATION_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_DILATION_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_GROUPS, 4) &&
           verifier.EndTable();
  }
};
 
struct Conv2dOpBuilder {
  typedef Conv2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(Conv2dOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::TensorRef> weight) {
    fbb_.AddOffset(Conv2dOp::VT_WEIGHT, weight);
  }
  void add_bias(::flatbuffers::Offset<tt::target::TensorRef> bias) {
    fbb_.AddOffset(Conv2dOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(Conv2dOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(Conv2dOp::VT_DEVICE, device);
  }
  void add_in_channels(uint32_t in_channels) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_IN_CHANNELS, in_channels, 0);
  }
  void add_out_channels(uint32_t out_channels) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_OUT_CHANNELS, out_channels, 0);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_kernel_height(uint32_t kernel_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_KERNEL_HEIGHT, kernel_height, 0);
  }
  void add_kernel_width(uint32_t kernel_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_KERNEL_WIDTH, kernel_width, 0);
  }
  void add_stride_height(uint32_t stride_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_STRIDE_HEIGHT, stride_height, 0);
  }
  void add_stride_width(uint32_t stride_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_STRIDE_WIDTH, stride_width, 0);
  }
  void add_padding_height(uint32_t padding_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_PADDING_HEIGHT, padding_height, 0);
  }
  void add_padding_width(uint32_t padding_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_PADDING_WIDTH, padding_width, 0);
  }
  void add_dilation_height(uint32_t dilation_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_DILATION_HEIGHT, dilation_height, 0);
  }
  void add_dilation_width(uint32_t dilation_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_DILATION_WIDTH, dilation_width, 0);
  }
  void add_groups(uint32_t groups) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_GROUPS, groups, 0);
  }
  explicit Conv2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Conv2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Conv2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Conv2dOp> CreateConv2dOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    uint32_t kernel_height = 0,
    uint32_t kernel_width = 0,
    uint32_t stride_height = 0,
    uint32_t stride_width = 0,
    uint32_t padding_height = 0,
    uint32_t padding_width = 0,
    uint32_t dilation_height = 0,
    uint32_t dilation_width = 0,
    uint32_t groups = 0) {
  Conv2dOpBuilder builder_(_fbb);
  builder_.add_groups(groups);
  builder_.add_dilation_width(dilation_width);
  builder_.add_dilation_height(dilation_height);
  builder_.add_padding_width(padding_width);
  builder_.add_padding_height(padding_height);
  builder_.add_stride_width(stride_width);
  builder_.add_stride_height(stride_height);
  builder_.add_kernel_width(kernel_width);
  builder_.add_kernel_height(kernel_height);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_out_channels(out_channels);
  builder_.add_in_channels(in_channels);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_bias(bias);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct Conv2dOp::Traits {
  using type = Conv2dOp;
  static auto constexpr Create = CreateConv2dOp;
};
 
struct MaxPool2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MaxPool2dOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DEVICE = 8,
    VT_BATCH_SIZE = 10,
    VT_INPUT_HEIGHT = 12,
    VT_INPUT_WIDTH = 14,
    VT_CHANNELS = 16,
    VT_KERNEL_HEIGHT = 18,
    VT_KERNEL_WIDTH = 20,
    VT_STRIDE_HEIGHT = 22,
    VT_STRIDE_WIDTH = 24,
    VT_DILATION_HEIGHT = 26,
    VT_DILATION_WIDTH = 28,
    VT_CEIL_MODE = 30,
    VT_PADDING_HEIGHT = 32,
    VT_PADDING_WIDTH = 34
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const tt::target::TensorRef *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  uint32_t channels() const {
    return GetField<uint32_t>(VT_CHANNELS, 0);
  }
  uint32_t kernel_height() const {
    return GetField<uint32_t>(VT_KERNEL_HEIGHT, 0);
  }
  uint32_t kernel_width() const {
    return GetField<uint32_t>(VT_KERNEL_WIDTH, 0);
  }
  uint32_t stride_height() const {
    return GetField<uint32_t>(VT_STRIDE_HEIGHT, 0);
  }
  uint32_t stride_width() const {
    return GetField<uint32_t>(VT_STRIDE_WIDTH, 0);
  }
  uint32_t dilation_height() const {
    return GetField<uint32_t>(VT_DILATION_HEIGHT, 0);
  }
  uint32_t dilation_width() const {
    return GetField<uint32_t>(VT_DILATION_WIDTH, 0);
  }
  bool ceil_mode() const {
    return GetField<uint8_t>(VT_CEIL_MODE, 0) != 0;
  }
  uint32_t padding_height() const {
    return GetField<uint32_t>(VT_PADDING_HEIGHT, 0);
  }
  uint32_t padding_width() const {
    return GetField<uint32_t>(VT_PADDING_WIDTH, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_KERNEL_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_KERNEL_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_STRIDE_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_STRIDE_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_DILATION_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_DILATION_WIDTH, 4) &&
           VerifyField<uint8_t>(verifier, VT_CEIL_MODE, 1) &&
           VerifyField<uint32_t>(verifier, VT_PADDING_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_PADDING_WIDTH, 4) &&
           verifier.EndTable();
  }
};
 
struct MaxPool2dOpBuilder {
  typedef MaxPool2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(MaxPool2dOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(MaxPool2dOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(MaxPool2dOp::VT_DEVICE, device);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_channels(uint32_t channels) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_CHANNELS, channels, 0);
  }
  void add_kernel_height(uint32_t kernel_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_KERNEL_HEIGHT, kernel_height, 0);
  }
  void add_kernel_width(uint32_t kernel_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_KERNEL_WIDTH, kernel_width, 0);
  }
  void add_stride_height(uint32_t stride_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_STRIDE_HEIGHT, stride_height, 0);
  }
  void add_stride_width(uint32_t stride_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_STRIDE_WIDTH, stride_width, 0);
  }
  void add_dilation_height(uint32_t dilation_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_DILATION_HEIGHT, dilation_height, 0);
  }
  void add_dilation_width(uint32_t dilation_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_DILATION_WIDTH, dilation_width, 0);
  }
  void add_ceil_mode(bool ceil_mode) {
    fbb_.AddElement<uint8_t>(MaxPool2dOp::VT_CEIL_MODE, static_cast<uint8_t>(ceil_mode), 0);
  }
  void add_padding_height(uint32_t padding_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_PADDING_HEIGHT, padding_height, 0);
  }
  void add_padding_width(uint32_t padding_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_PADDING_WIDTH, padding_width, 0);
  }
  explicit MaxPool2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MaxPool2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MaxPool2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MaxPool2dOp> CreateMaxPool2dOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    uint32_t channels = 0,
    uint32_t kernel_height = 0,
    uint32_t kernel_width = 0,
    uint32_t stride_height = 0,
    uint32_t stride_width = 0,
    uint32_t dilation_height = 0,
    uint32_t dilation_width = 0,
    bool ceil_mode = false,
    uint32_t padding_height = 0,
    uint32_t padding_width = 0) {
  MaxPool2dOpBuilder builder_(_fbb);
  builder_.add_padding_width(padding_width);
  builder_.add_padding_height(padding_height);
  builder_.add_dilation_width(dilation_width);
  builder_.add_dilation_height(dilation_height);
  builder_.add_stride_width(stride_width);
  builder_.add_stride_height(stride_height);
  builder_.add_kernel_width(kernel_width);
  builder_.add_kernel_height(kernel_height);
  builder_.add_channels(channels);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_ceil_mode(ceil_mode);
  return builder_.Finish();
}
 
struct MaxPool2dOp::Traits {
  using type = MaxPool2dOp;
  static auto constexpr Create = CreateMaxPool2dOp;
};
 
struct DeallocOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DeallocOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           verifier.EndTable();
  }
};
 
struct DeallocOpBuilder {
  typedef DeallocOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(DeallocOp::VT_IN, in);
  }
  explicit DeallocOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DeallocOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DeallocOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DeallocOp> CreateDeallocOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0) {
  DeallocOpBuilder builder_(_fbb);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct DeallocOp::Traits {
  using type = DeallocOp;
  static auto constexpr Create = CreateDeallocOp;
};
 
struct Operation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OperationBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE_TYPE = 4,
    VT_TYPE = 6,
    VT_DEBUG_INFO = 8
  };
  tt::target::ttnn::OpType type_type() const {
    return static_cast<tt::target::ttnn::OpType>(GetField<uint8_t>(VT_TYPE_TYPE, 0));
  }
  const void *type() const {
    return GetPointer<const void *>(VT_TYPE);
  }
  template<typename T> const T *type_as() const;
  const tt::target::ttnn::GetDeviceOp *type_as_GetDeviceOp() const {
    return type_type() == tt::target::ttnn::OpType::GetDeviceOp ? static_cast<const tt::target::ttnn::GetDeviceOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ToMemoryConfigOp *type_as_ToMemoryConfigOp() const {
    return type_type() == tt::target::ttnn::OpType::ToMemoryConfigOp ? static_cast<const tt::target::ttnn::ToMemoryConfigOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ToLayoutOp *type_as_ToLayoutOp() const {
    return type_type() == tt::target::ttnn::OpType::ToLayoutOp ? static_cast<const tt::target::ttnn::ToLayoutOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ToDeviceOp *type_as_ToDeviceOp() const {
    return type_type() == tt::target::ttnn::OpType::ToDeviceOp ? static_cast<const tt::target::ttnn::ToDeviceOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::FromDeviceOp *type_as_FromDeviceOp() const {
    return type_type() == tt::target::ttnn::OpType::FromDeviceOp ? static_cast<const tt::target::ttnn::FromDeviceOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EmptyOp *type_as_EmptyOp() const {
    return type_type() == tt::target::ttnn::OpType::EmptyOp ? static_cast<const tt::target::ttnn::EmptyOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::FullOp *type_as_FullOp() const {
    return type_type() == tt::target::ttnn::OpType::FullOp ? static_cast<const tt::target::ttnn::FullOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseOp *type_as_EltwiseOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseOp ? static_cast<const tt::target::ttnn::EltwiseOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::MatmulOp *type_as_MatmulOp() const {
    return type_type() == tt::target::ttnn::OpType::MatmulOp ? static_cast<const tt::target::ttnn::MatmulOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ReductionOp *type_as_ReductionOp() const {
    return type_type() == tt::target::ttnn::OpType::ReductionOp ? static_cast<const tt::target::ttnn::ReductionOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EmbeddingOp *type_as_EmbeddingOp() const {
    return type_type() == tt::target::ttnn::OpType::EmbeddingOp ? static_cast<const tt::target::ttnn::EmbeddingOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::SoftmaxOp *type_as_SoftmaxOp() const {
    return type_type() == tt::target::ttnn::OpType::SoftmaxOp ? static_cast<const tt::target::ttnn::SoftmaxOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::TransposeOp *type_as_TransposeOp() const {
    return type_type() == tt::target::ttnn::OpType::TransposeOp ? static_cast<const tt::target::ttnn::TransposeOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::Conv2dOp *type_as_Conv2dOp() const {
    return type_type() == tt::target::ttnn::OpType::Conv2dOp ? static_cast<const tt::target::ttnn::Conv2dOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ConcatOp *type_as_ConcatOp() const {
    return type_type() == tt::target::ttnn::OpType::ConcatOp ? static_cast<const tt::target::ttnn::ConcatOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ReshapeOp *type_as_ReshapeOp() const {
    return type_type() == tt::target::ttnn::OpType::ReshapeOp ? static_cast<const tt::target::ttnn::ReshapeOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::MaxPool2dOp *type_as_MaxPool2dOp() const {
    return type_type() == tt::target::ttnn::OpType::MaxPool2dOp ? static_cast<const tt::target::ttnn::MaxPool2dOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::DeallocOp *type_as_DeallocOp() const {
    return type_type() == tt::target::ttnn::OpType::DeallocOp ? static_cast<const tt::target::ttnn::DeallocOp *>(type()) : nullptr;
  }
  const ::flatbuffers::String *debug_info() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DEBUG_INFO);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE, 1) &&
           VerifyOffset(verifier, VT_TYPE) &&
           VerifyOpType(verifier, type(), type_type()) &&
           VerifyOffset(verifier, VT_DEBUG_INFO) &&
           verifier.VerifyString(debug_info()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::GetDeviceOp *Operation::type_as<tt::target::ttnn::GetDeviceOp>() const {
  return type_as_GetDeviceOp();
}
 
template<> inline const tt::target::ttnn::ToMemoryConfigOp *Operation::type_as<tt::target::ttnn::ToMemoryConfigOp>() const {
  return type_as_ToMemoryConfigOp();
}
 
template<> inline const tt::target::ttnn::ToLayoutOp *Operation::type_as<tt::target::ttnn::ToLayoutOp>() const {
  return type_as_ToLayoutOp();
}
 
template<> inline const tt::target::ttnn::ToDeviceOp *Operation::type_as<tt::target::ttnn::ToDeviceOp>() const {
  return type_as_ToDeviceOp();
}
 
template<> inline const tt::target::ttnn::FromDeviceOp *Operation::type_as<tt::target::ttnn::FromDeviceOp>() const {
  return type_as_FromDeviceOp();
}
 
template<> inline const tt::target::ttnn::EmptyOp *Operation::type_as<tt::target::ttnn::EmptyOp>() const {
  return type_as_EmptyOp();
}
 
template<> inline const tt::target::ttnn::FullOp *Operation::type_as<tt::target::ttnn::FullOp>() const {
  return type_as_FullOp();
}
 
template<> inline const tt::target::ttnn::EltwiseOp *Operation::type_as<tt::target::ttnn::EltwiseOp>() const {
  return type_as_EltwiseOp();
}
 
template<> inline const tt::target::ttnn::MatmulOp *Operation::type_as<tt::target::ttnn::MatmulOp>() const {
  return type_as_MatmulOp();
}
 
template<> inline const tt::target::ttnn::ReductionOp *Operation::type_as<tt::target::ttnn::ReductionOp>() const {
  return type_as_ReductionOp();
}
 
template<> inline const tt::target::ttnn::EmbeddingOp *Operation::type_as<tt::target::ttnn::EmbeddingOp>() const {
  return type_as_EmbeddingOp();
}
 
template<> inline const tt::target::ttnn::SoftmaxOp *Operation::type_as<tt::target::ttnn::SoftmaxOp>() const {
  return type_as_SoftmaxOp();
}
 
template<> inline const tt::target::ttnn::TransposeOp *Operation::type_as<tt::target::ttnn::TransposeOp>() const {
  return type_as_TransposeOp();
}
 
template<> inline const tt::target::ttnn::Conv2dOp *Operation::type_as<tt::target::ttnn::Conv2dOp>() const {
  return type_as_Conv2dOp();
}
 
template<> inline const tt::target::ttnn::ConcatOp *Operation::type_as<tt::target::ttnn::ConcatOp>() const {
  return type_as_ConcatOp();
}
 
template<> inline const tt::target::ttnn::ReshapeOp *Operation::type_as<tt::target::ttnn::ReshapeOp>() const {
  return type_as_ReshapeOp();
}
 
template<> inline const tt::target::ttnn::MaxPool2dOp *Operation::type_as<tt::target::ttnn::MaxPool2dOp>() const {
  return type_as_MaxPool2dOp();
}
 
template<> inline const tt::target::ttnn::DeallocOp *Operation::type_as<tt::target::ttnn::DeallocOp>() const {
  return type_as_DeallocOp();
}
 
struct OperationBuilder {
  typedef Operation Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type_type(tt::target::ttnn::OpType type_type) {
    fbb_.AddElement<uint8_t>(Operation::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
  }
  void add_type(::flatbuffers::Offset<void> type) {
    fbb_.AddOffset(Operation::VT_TYPE, type);
  }
  void add_debug_info(::flatbuffers::Offset<::flatbuffers::String> debug_info) {
    fbb_.AddOffset(Operation::VT_DEBUG_INFO, debug_info);
  }
  explicit OperationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Operation> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Operation>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Operation> CreateOperation(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::OpType type_type = tt::target::ttnn::OpType::NONE,
    ::flatbuffers::Offset<void> type = 0,
    ::flatbuffers::Offset<::flatbuffers::String> debug_info = 0) {
  OperationBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  builder_.add_type(type);
  builder_.add_type_type(type_type);
  return builder_.Finish();
}
 
struct Operation::Traits {
  using type = Operation;
  static auto constexpr Create = CreateOperation;
};
 
inline ::flatbuffers::Offset<Operation> CreateOperationDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::OpType type_type = tt::target::ttnn::OpType::NONE,
    ::flatbuffers::Offset<void> type = 0,
    const char *debug_info = nullptr) {
  auto debug_info__ = debug_info ? _fbb.CreateString(debug_info) : 0;
  return tt::target::ttnn::CreateOperation(
      _fbb,
      type_type,
      type,
      debug_info__);
}
 
struct Program FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ProgramBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_INPUTS = 6,
    VT_OUTPUTS = 8,
    VT_OPERATIONS = 10,
    VT_DEBUG_INFO = 12
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>> *>(VT_OUTPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::Operation>> *operations() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::Operation>> *>(VT_OPERATIONS);
  }
  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_OPERATIONS) &&
           verifier.VerifyVector(operations()) &&
           verifier.VerifyVectorOfTables(operations()) &&
           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::TensorRef>>> inputs) {
    fbb_.AddOffset(Program::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> outputs) {
    fbb_.AddOffset(Program::VT_OUTPUTS, outputs);
  }
  void add_operations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::Operation>>> operations) {
    fbb_.AddOffset(Program::VT_OPERATIONS, operations);
  }
  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::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::TensorRef>>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::Operation>>> operations = 0,
    ::flatbuffers::Offset<tt::target::DebugInfo> debug_info = 0) {
  ProgramBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  builder_.add_operations(operations);
  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::TensorRef>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::TensorRef>> *outputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::Operation>> *operations = 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::TensorRef>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::TensorRef>>(*outputs) : 0;
  auto operations__ = operations ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::Operation>>(*operations) : 0;
  return tt::target::ttnn::CreateProgram(
      _fbb,
      name__,
      inputs__,
      outputs__,
      operations__,
      debug_info);
}
 
inline bool VerifyOpType(::flatbuffers::Verifier &verifier, const void *obj, OpType type) {
  switch (type) {
    case OpType::NONE: {
      return true;
    }
    case OpType::GetDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::GetDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToMemoryConfigOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToMemoryConfigOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToLayoutOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToLayoutOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FromDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FromDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EmptyOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmptyOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FullOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FullOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::MatmulOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MatmulOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReductionOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReductionOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EmbeddingOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmbeddingOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::SoftmaxOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::SoftmaxOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::TransposeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::TransposeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::Conv2dOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::Conv2dOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ConcatOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ConcatOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReshapeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReshapeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::MaxPool2dOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MaxPool2dOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::DeallocOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::DeallocOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyOpTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<OpType> *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 (!VerifyOpType(
        verifier,  values->Get(i), types->GetEnum<OpType>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_PROGRAM_TT_TARGET_TTNN_H_