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 TypecastOp;
struct TypecastOpBuilder;
 
struct ToDeviceOp;
struct ToDeviceOpBuilder;
 
struct UpdateCacheOp;
struct UpdateCacheOpBuilder;
 
struct FillCacheOp;
struct FillCacheOpBuilder;
 
struct FromDeviceOp;
struct FromDeviceOpBuilder;
 
struct EmptyOp;
struct EmptyOpBuilder;
 
struct OnesOp;
struct OnesOpBuilder;
 
struct FullOp;
struct FullOpBuilder;
 
struct ArangeOp;
struct ArangeOpBuilder;
 
struct ClampOpParams;
struct ClampOpParamsBuilder;
 
struct EltwiseOpWithFloatParams;
struct EltwiseOpWithFloatParamsBuilder;
 
struct EltwiseOp;
struct EltwiseOpBuilder;
 
struct ReductionOp;
struct ReductionOpBuilder;
 
struct EmbeddingOp;
struct EmbeddingOpBuilder;
 
struct EmbeddingBackwardOp;
struct EmbeddingBackwardOpBuilder;
 
struct SoftmaxOp;
struct SoftmaxOpBuilder;
 
struct TransposeOp;
struct TransposeOpBuilder;
 
struct ConcatOp;
struct ConcatOpBuilder;
 
struct ReshapeOp;
struct ReshapeOpBuilder;
 
struct RepeatOp;
struct RepeatOpBuilder;
 
struct SliceOp;
struct SliceOpBuilder;
 
struct LinearOp;
struct LinearOpBuilder;
 
struct MatmulOp;
struct MatmulOpBuilder;
 
struct Conv2dOp;
struct Conv2dOpBuilder;
 
struct ConvTranspose2dOp;
struct ConvTranspose2dOpBuilder;
 
struct MaxPool2dOp;
struct MaxPool2dOpBuilder;
 
struct DeallocateOp;
struct DeallocateOpBuilder;
 
struct AllGatherOp;
struct AllGatherOpBuilder;
 
struct PermuteOp;
struct PermuteOpBuilder;
 
struct ReduceScatterOp;
struct ReduceScatterOpBuilder;
 
struct MeshShardOp;
struct MeshShardOpBuilder;
 
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,
  Rsqrt = 13,
  Typecast = 14,
  Equal = 15,
  NotEqual = 16,
  LessEqual = 17,
  LessThan = 18,
  GreaterThan = 19,
  LogicalAnd = 20,
  LogicalOr = 21,
  LogicalXor = 22,
  LogicalNot = 23,
  BitwiseAnd = 24,
  BitwiseOr = 25,
  BitwiseXor = 26,
  BitwiseNot = 27,
  Cbrt = 28,
  Minimum = 29,
  Ceil = 30,
  Sin = 31,
  Cos = 32,
  Log = 33,
  Log1p = 34,
  Expm1 = 35,
  Sign = 36,
  Remainder = 37,
  IsFinite = 38,
  Floor = 39,
  Where = 40,
  Gelu = 41,
  Clamp = 42,
  LeakyRelu = 43,
  Scatter = 44,
  Tan = 45,
  Tanh = 46,
  MIN = Add,
  MAX = Tanh
};
 
inline const EltwiseOpType (&EnumValuesEltwiseOpType())[47] {
  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,
    EltwiseOpType::Rsqrt,
    EltwiseOpType::Typecast,
    EltwiseOpType::Equal,
    EltwiseOpType::NotEqual,
    EltwiseOpType::LessEqual,
    EltwiseOpType::LessThan,
    EltwiseOpType::GreaterThan,
    EltwiseOpType::LogicalAnd,
    EltwiseOpType::LogicalOr,
    EltwiseOpType::LogicalXor,
    EltwiseOpType::LogicalNot,
    EltwiseOpType::BitwiseAnd,
    EltwiseOpType::BitwiseOr,
    EltwiseOpType::BitwiseXor,
    EltwiseOpType::BitwiseNot,
    EltwiseOpType::Cbrt,
    EltwiseOpType::Minimum,
    EltwiseOpType::Ceil,
    EltwiseOpType::Sin,
    EltwiseOpType::Cos,
    EltwiseOpType::Log,
    EltwiseOpType::Log1p,
    EltwiseOpType::Expm1,
    EltwiseOpType::Sign,
    EltwiseOpType::Remainder,
    EltwiseOpType::IsFinite,
    EltwiseOpType::Floor,
    EltwiseOpType::Where,
    EltwiseOpType::Gelu,
    EltwiseOpType::Clamp,
    EltwiseOpType::LeakyRelu,
    EltwiseOpType::Scatter,
    EltwiseOpType::Tan,
    EltwiseOpType::Tanh
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseOpType() {
  static const char * const names[48] = {
    "Add",
    "Multiply",
    "Subtract",
    "Relu",
    "GreaterEqual",
    "Sqrt",
    "Div",
    "Sigmoid",
    "Reciprocal",
    "Exp",
    "Maximum",
    "Abs",
    "Neg",
    "Rsqrt",
    "Typecast",
    "Equal",
    "NotEqual",
    "LessEqual",
    "LessThan",
    "GreaterThan",
    "LogicalAnd",
    "LogicalOr",
    "LogicalXor",
    "LogicalNot",
    "BitwiseAnd",
    "BitwiseOr",
    "BitwiseXor",
    "BitwiseNot",
    "Cbrt",
    "Minimum",
    "Ceil",
    "Sin",
    "Cos",
    "Log",
    "Log1p",
    "Expm1",
    "Sign",
    "Remainder",
    "IsFinite",
    "Floor",
    "Where",
    "Gelu",
    "Clamp",
    "LeakyRelu",
    "Scatter",
    "Tan",
    "Tanh",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseOpType(EltwiseOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseOpType::Add, EltwiseOpType::Tanh)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseOpType()[index];
}
 
enum class EltwiseOpParams : uint8_t {
  NONE = 0,
  ClampOpParams = 1,
  EltwiseOpWithFloatParams = 2,
  MIN = NONE,
  MAX = EltwiseOpWithFloatParams
};
 
inline const EltwiseOpParams (&EnumValuesEltwiseOpParams())[3] {
  static const EltwiseOpParams values[] = {
    EltwiseOpParams::NONE,
    EltwiseOpParams::ClampOpParams,
    EltwiseOpParams::EltwiseOpWithFloatParams
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseOpParams() {
  static const char * const names[4] = {
    "NONE",
    "ClampOpParams",
    "EltwiseOpWithFloatParams",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseOpParams(EltwiseOpParams e) {
  if (::flatbuffers::IsOutRange(e, EltwiseOpParams::NONE, EltwiseOpParams::EltwiseOpWithFloatParams)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseOpParams()[index];
}
 
template<typename T> struct EltwiseOpParamsTraits {
  static const EltwiseOpParams enum_value = EltwiseOpParams::NONE;
};
 
template<> struct EltwiseOpParamsTraits<tt::target::ttnn::ClampOpParams> {
  static const EltwiseOpParams enum_value = EltwiseOpParams::ClampOpParams;
};
 
template<> struct EltwiseOpParamsTraits<tt::target::ttnn::EltwiseOpWithFloatParams> {
  static const EltwiseOpParams enum_value = EltwiseOpParams::EltwiseOpWithFloatParams;
};
 
bool VerifyEltwiseOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseOpParams type);
bool VerifyEltwiseOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseOpParams> *types);
 
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,
  TypecastOp = 4,
  ToDeviceOp = 5,
  FromDeviceOp = 6,
  EmptyOp = 7,
  OnesOp = 8,
  FullOp = 9,
  EltwiseOp = 10,
  LinearOp = 11,
  MatmulOp = 12,
  ReductionOp = 13,
  EmbeddingOp = 14,
  EmbeddingBackwardOp = 15,
  SoftmaxOp = 16,
  TransposeOp = 17,
  Conv2dOp = 18,
  ConvTranspose2dOp = 19,
  ConcatOp = 20,
  ReshapeOp = 21,
  SliceOp = 22,
  MaxPool2dOp = 23,
  DeallocateOp = 24,
  AllGatherOp = 25,
  ReduceScatterOp = 26,
  MeshShardOp = 27,
  ArangeOp = 28,
  UpdateCacheOp = 29,
  FillCacheOp = 30,
  PermuteOp = 31,
  RepeatOp = 32,
  MIN = NONE,
  MAX = RepeatOp
};
 
inline const OpType (&EnumValuesOpType())[33] {
  static const OpType values[] = {
    OpType::NONE,
    OpType::GetDeviceOp,
    OpType::ToMemoryConfigOp,
    OpType::ToLayoutOp,
    OpType::TypecastOp,
    OpType::ToDeviceOp,
    OpType::FromDeviceOp,
    OpType::EmptyOp,
    OpType::OnesOp,
    OpType::FullOp,
    OpType::EltwiseOp,
    OpType::LinearOp,
    OpType::MatmulOp,
    OpType::ReductionOp,
    OpType::EmbeddingOp,
    OpType::EmbeddingBackwardOp,
    OpType::SoftmaxOp,
    OpType::TransposeOp,
    OpType::Conv2dOp,
    OpType::ConvTranspose2dOp,
    OpType::ConcatOp,
    OpType::ReshapeOp,
    OpType::SliceOp,
    OpType::MaxPool2dOp,
    OpType::DeallocateOp,
    OpType::AllGatherOp,
    OpType::ReduceScatterOp,
    OpType::MeshShardOp,
    OpType::ArangeOp,
    OpType::UpdateCacheOp,
    OpType::FillCacheOp,
    OpType::PermuteOp,
    OpType::RepeatOp
  };
  return values;
}
 
inline const char * const *EnumNamesOpType() {
  static const char * const names[34] = {
    "NONE",
    "GetDeviceOp",
    "ToMemoryConfigOp",
    "ToLayoutOp",
    "TypecastOp",
    "ToDeviceOp",
    "FromDeviceOp",
    "EmptyOp",
    "OnesOp",
    "FullOp",
    "EltwiseOp",
    "LinearOp",
    "MatmulOp",
    "ReductionOp",
    "EmbeddingOp",
    "EmbeddingBackwardOp",
    "SoftmaxOp",
    "TransposeOp",
    "Conv2dOp",
    "ConvTranspose2dOp",
    "ConcatOp",
    "ReshapeOp",
    "SliceOp",
    "MaxPool2dOp",
    "DeallocateOp",
    "AllGatherOp",
    "ReduceScatterOp",
    "MeshShardOp",
    "ArangeOp",
    "UpdateCacheOp",
    "FillCacheOp",
    "PermuteOp",
    "RepeatOp",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameOpType(OpType e) {
  if (::flatbuffers::IsOutRange(e, OpType::NONE, OpType::RepeatOp)) 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::TypecastOp> {
  static const OpType enum_value = OpType::TypecastOp;
};
 
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::OnesOp> {
  static const OpType enum_value = OpType::OnesOp;
};
 
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::LinearOp> {
  static const OpType enum_value = OpType::LinearOp;
};
 
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::EmbeddingBackwardOp> {
  static const OpType enum_value = OpType::EmbeddingBackwardOp;
};
 
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::ConvTranspose2dOp> {
  static const OpType enum_value = OpType::ConvTranspose2dOp;
};
 
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::SliceOp> {
  static const OpType enum_value = OpType::SliceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::MaxPool2dOp> {
  static const OpType enum_value = OpType::MaxPool2dOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::DeallocateOp> {
  static const OpType enum_value = OpType::DeallocateOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::AllGatherOp> {
  static const OpType enum_value = OpType::AllGatherOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReduceScatterOp> {
  static const OpType enum_value = OpType::ReduceScatterOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::MeshShardOp> {
  static const OpType enum_value = OpType::MeshShardOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ArangeOp> {
  static const OpType enum_value = OpType::ArangeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::UpdateCacheOp> {
  static const OpType enum_value = OpType::UpdateCacheOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FillCacheOp> {
  static const OpType enum_value = OpType::FillCacheOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::PermuteOp> {
  static const OpType enum_value = OpType::PermuteOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::RepeatOp> {
  static const OpType enum_value = OpType::RepeatOp;
};
 
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_MEMCFG = 6,
    VT_OUT = 8
  };
  const tt::target::TensorRef *in0() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN0);
  }
  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_IN0) &&
           verifier.VerifyTable(in0()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           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_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_MEMCFG, memcfg);
  }
  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::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  ToMemoryConfigOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  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_DTYPE = 8,
    VT_MEMCFG = 10,
    VT_DEVICE = 12,
    VT_OUT = 14
  };
  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));
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  const tt::target::MemoryConfigDesc *memcfg() const {
    return GetPointer<const tt::target::MemoryConfigDesc *>(VT_MEMCFG);
  }
  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) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           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_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ToLayoutOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(ToLayoutOp::VT_MEMCFG, memcfg);
  }
  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::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::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_memcfg(memcfg);
  builder_.add_in(in);
  if(dtype) { builder_.add_dtype(*dtype); }
  builder_.add_layout(layout);
  return builder_.Finish();
}
 
struct ToLayoutOp::Traits {
  using type = ToLayoutOp;
  static auto constexpr Create = CreateToLayoutOp;
};
 
struct TypecastOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TypecastOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_DTYPE = 6,
    VT_OUT = 8
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  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_DTYPE, 2) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct TypecastOpBuilder {
  typedef TypecastOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(TypecastOp::VT_IN, in);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(TypecastOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(TypecastOp::VT_OUT, out);
  }
  explicit TypecastOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TypecastOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TypecastOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TypecastOp> CreateTypecastOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  TypecastOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct TypecastOp::Traits {
  using type = TypecastOp;
  static auto constexpr Create = CreateTypecastOp;
};
 
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 UpdateCacheOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UpdateCacheOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CACHE = 4,
    VT_INPUT = 6,
    VT_UPDATE_INDEX = 8,
    VT_BATCH_OFFSET = 10
  };
  const tt::target::TensorRef *cache() const {
    return GetPointer<const tt::target::TensorRef *>(VT_CACHE);
  }
  const tt::target::TensorRef *input() const {
    return GetPointer<const tt::target::TensorRef *>(VT_INPUT);
  }
  const tt::target::TensorRef *update_index() const {
    return GetPointer<const tt::target::TensorRef *>(VT_UPDATE_INDEX);
  }
  uint32_t batch_offset() const {
    return GetField<uint32_t>(VT_BATCH_OFFSET, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CACHE) &&
           verifier.VerifyTable(cache()) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_UPDATE_INDEX) &&
           verifier.VerifyTable(update_index()) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_OFFSET, 4) &&
           verifier.EndTable();
  }
};
 
struct UpdateCacheOpBuilder {
  typedef UpdateCacheOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_cache(::flatbuffers::Offset<tt::target::TensorRef> cache) {
    fbb_.AddOffset(UpdateCacheOp::VT_CACHE, cache);
  }
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(UpdateCacheOp::VT_INPUT, input);
  }
  void add_update_index(::flatbuffers::Offset<tt::target::TensorRef> update_index) {
    fbb_.AddOffset(UpdateCacheOp::VT_UPDATE_INDEX, update_index);
  }
  void add_batch_offset(uint32_t batch_offset) {
    fbb_.AddElement<uint32_t>(UpdateCacheOp::VT_BATCH_OFFSET, batch_offset, 0);
  }
  explicit UpdateCacheOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UpdateCacheOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UpdateCacheOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<UpdateCacheOp> CreateUpdateCacheOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> cache = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> update_index = 0,
    uint32_t batch_offset = 0) {
  UpdateCacheOpBuilder builder_(_fbb);
  builder_.add_batch_offset(batch_offset);
  builder_.add_update_index(update_index);
  builder_.add_input(input);
  builder_.add_cache(cache);
  return builder_.Finish();
}
 
struct UpdateCacheOp::Traits {
  using type = UpdateCacheOp;
  static auto constexpr Create = CreateUpdateCacheOp;
};
 
struct FillCacheOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FillCacheOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CACHE = 4,
    VT_INPUT = 6,
    VT_BATCH_OFFSET = 8
  };
  const tt::target::TensorRef *cache() const {
    return GetPointer<const tt::target::TensorRef *>(VT_CACHE);
  }
  const tt::target::TensorRef *input() const {
    return GetPointer<const tt::target::TensorRef *>(VT_INPUT);
  }
  uint32_t batch_offset() const {
    return GetField<uint32_t>(VT_BATCH_OFFSET, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CACHE) &&
           verifier.VerifyTable(cache()) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_OFFSET, 4) &&
           verifier.EndTable();
  }
};
 
struct FillCacheOpBuilder {
  typedef FillCacheOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_cache(::flatbuffers::Offset<tt::target::TensorRef> cache) {
    fbb_.AddOffset(FillCacheOp::VT_CACHE, cache);
  }
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(FillCacheOp::VT_INPUT, input);
  }
  void add_batch_offset(uint32_t batch_offset) {
    fbb_.AddElement<uint32_t>(FillCacheOp::VT_BATCH_OFFSET, batch_offset, 0);
  }
  explicit FillCacheOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FillCacheOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FillCacheOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FillCacheOp> CreateFillCacheOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> cache = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> input = 0,
    uint32_t batch_offset = 0) {
  FillCacheOpBuilder builder_(_fbb);
  builder_.add_batch_offset(batch_offset);
  builder_.add_input(input);
  builder_.add_cache(cache);
  return builder_.Finish();
}
 
struct FillCacheOp::Traits {
  using type = FillCacheOp;
  static auto constexpr Create = CreateFillCacheOp;
};
 
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_NUM_SHARDS = 10,
    VT_DEVICE = 12,
    VT_MEMCFG = 14,
    VT_STRATEGY = 16,
    VT_OUT = 18
  };
  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));
  }
  uint32_t num_shards() const {
    return GetField<uint32_t>(VT_NUM_SHARDS, 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::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::DistributionStrategy *>(VT_STRATEGY);
  }
  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) &&
           VerifyField<uint32_t>(verifier, VT_NUM_SHARDS, 4) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           verifier.VerifyTable(strategy()) &&
           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_num_shards(uint32_t num_shards) {
    fbb_.AddElement<uint32_t>(EmptyOp::VT_NUM_SHARDS, num_shards, 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_strategy(::flatbuffers::Offset<tt::target::DistributionStrategy> strategy) {
    fbb_.AddOffset(EmptyOp::VT_STRATEGY, strategy);
  }
  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,
    uint32_t num_shards = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::DistributionStrategy> strategy = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  EmptyOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_strategy(strategy);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_num_shards(num_shards);
  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,
    uint32_t num_shards = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::DistributionStrategy> strategy = 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,
      num_shards,
      device,
      memcfg,
      strategy,
      out);
}
 
struct OnesOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OnesOpBuilder 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);
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  ::flatbuffers::Optional<tt::target::TensorLayout> layout() const {
    return GetOptional<uint16_t, tt::target::TensorLayout>(VT_LAYOUT);
  }
  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 OnesOpBuilder {
  typedef OnesOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(OnesOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(OnesOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(OnesOp::VT_LAYOUT, static_cast<uint16_t>(layout));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(OnesOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(OnesOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(OnesOp::VT_OUT, out);
  }
  explicit OnesOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<OnesOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<OnesOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<OnesOp> CreateOnesOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  OnesOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_shape(shape);
  if(layout) { builder_.add_layout(*layout); }
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct OnesOp::Traits {
  using type = OnesOp;
  static auto constexpr Create = CreateOnesOp;
};
 
inline ::flatbuffers::Offset<OnesOp> CreateOnesOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *shape = nullptr,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::TensorLayout> layout = ::flatbuffers::nullopt,
    ::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::CreateOnesOp(
      _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_NUM_SHARDS = 8,
    VT_STRATEGY = 10,
    VT_OUT = 12
  };
  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);
  }
  uint32_t num_shards() const {
    return GetField<uint32_t>(VT_NUM_SHARDS, 0);
  }
  const tt::target::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::DistributionStrategy *>(VT_STRATEGY);
  }
  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) &&
           VerifyField<uint32_t>(verifier, VT_NUM_SHARDS, 4) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           verifier.VerifyTable(strategy()) &&
           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_num_shards(uint32_t num_shards) {
    fbb_.AddElement<uint32_t>(FullOp::VT_NUM_SHARDS, num_shards, 0);
  }
  void add_strategy(::flatbuffers::Offset<tt::target::DistributionStrategy> strategy) {
    fbb_.AddOffset(FullOp::VT_STRATEGY, strategy);
  }
  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,
    uint32_t num_shards = 0,
    ::flatbuffers::Offset<tt::target::DistributionStrategy> strategy = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  FullOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_strategy(strategy);
  builder_.add_num_shards(num_shards);
  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 ArangeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ArangeOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_START = 4,
    VT_END = 6,
    VT_STEP = 8,
    VT_DTYPE = 10,
    VT_DEVICE = 12,
    VT_MEMCFG = 14,
    VT_OUT = 16
  };
  float start() const {
    return GetField<float>(VT_START, 0.0f);
  }
  float end() const {
    return GetField<float>(VT_END, 0.0f);
  }
  float step() const {
    return GetField<float>(VT_STEP, 0.0f);
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  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) &&
           VerifyField<float>(verifier, VT_START, 4) &&
           VerifyField<float>(verifier, VT_END, 4) &&
           VerifyField<float>(verifier, VT_STEP, 4) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 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 ArangeOpBuilder {
  typedef ArangeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_start(float start) {
    fbb_.AddElement<float>(ArangeOp::VT_START, start, 0.0f);
  }
  void add_end(float end) {
    fbb_.AddElement<float>(ArangeOp::VT_END, end, 0.0f);
  }
  void add_step(float step) {
    fbb_.AddElement<float>(ArangeOp::VT_STEP, step, 0.0f);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ArangeOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ArangeOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(ArangeOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ArangeOp::VT_OUT, out);
  }
  explicit ArangeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ArangeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ArangeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ArangeOp> CreateArangeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float start = 0.0f,
    float end = 0.0f,
    float step = 0.0f,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  ArangeOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_step(step);
  builder_.add_end(end);
  builder_.add_start(start);
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct ArangeOp::Traits {
  using type = ArangeOp;
  static auto constexpr Create = CreateArangeOp;
};
 
struct ClampOpParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ClampOpParamsBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MIN = 4,
    VT_MAX = 6
  };
  float min() const {
    return GetField<float>(VT_MIN, 0.0f);
  }
  float max() const {
    return GetField<float>(VT_MAX, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_MIN, 4) &&
           VerifyField<float>(verifier, VT_MAX, 4) &&
           verifier.EndTable();
  }
};
 
struct ClampOpParamsBuilder {
  typedef ClampOpParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_min(float min) {
    fbb_.AddElement<float>(ClampOpParams::VT_MIN, min, 0.0f);
  }
  void add_max(float max) {
    fbb_.AddElement<float>(ClampOpParams::VT_MAX, max, 0.0f);
  }
  explicit ClampOpParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ClampOpParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ClampOpParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ClampOpParams> CreateClampOpParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float min = 0.0f,
    float max = 0.0f) {
  ClampOpParamsBuilder builder_(_fbb);
  builder_.add_max(max);
  builder_.add_min(min);
  return builder_.Finish();
}
 
struct ClampOpParams::Traits {
  using type = ClampOpParams;
  static auto constexpr Create = CreateClampOpParams;
};
 
struct EltwiseOpWithFloatParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseOpWithFloatParamsBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PARAMETER = 4
  };
  float parameter() const {
    return GetField<float>(VT_PARAMETER, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_PARAMETER, 4) &&
           verifier.EndTable();
  }
};
 
struct EltwiseOpWithFloatParamsBuilder {
  typedef EltwiseOpWithFloatParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_parameter(float parameter) {
    fbb_.AddElement<float>(EltwiseOpWithFloatParams::VT_PARAMETER, parameter, 0.0f);
  }
  explicit EltwiseOpWithFloatParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseOpWithFloatParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseOpWithFloatParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseOpWithFloatParams> CreateEltwiseOpWithFloatParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float parameter = 0.0f) {
  EltwiseOpWithFloatParamsBuilder builder_(_fbb);
  builder_.add_parameter(parameter);
  return builder_.Finish();
}
 
struct EltwiseOpWithFloatParams::Traits {
  using type = EltwiseOpWithFloatParams;
  static auto constexpr Create = CreateEltwiseOpWithFloatParams;
};
 
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,
    VT_PARAMS_TYPE = 10,
    VT_PARAMS = 12
  };
  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);
  }
  tt::target::ttnn::EltwiseOpParams params_type() const {
    return static_cast<tt::target::ttnn::EltwiseOpParams>(GetField<uint8_t>(VT_PARAMS_TYPE, 0));
  }
  const void *params() const {
    return GetPointer<const void *>(VT_PARAMS);
  }
  template<typename T> const T *params_as() const;
  const tt::target::ttnn::ClampOpParams *params_as_ClampOpParams() const {
    return params_type() == tt::target::ttnn::EltwiseOpParams::ClampOpParams ? static_cast<const tt::target::ttnn::ClampOpParams *>(params()) : nullptr;
  }
  const tt::target::ttnn::EltwiseOpWithFloatParams *params_as_EltwiseOpWithFloatParams() const {
    return params_type() == tt::target::ttnn::EltwiseOpParams::EltwiseOpWithFloatParams ? static_cast<const tt::target::ttnn::EltwiseOpWithFloatParams *>(params()) : nullptr;
  }
  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()) &&
           VerifyField<uint8_t>(verifier, VT_PARAMS_TYPE, 1) &&
           VerifyOffset(verifier, VT_PARAMS) &&
           VerifyEltwiseOpParams(verifier, params(), params_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::ClampOpParams *EltwiseOp::params_as<tt::target::ttnn::ClampOpParams>() const {
  return params_as_ClampOpParams();
}
 
template<> inline const tt::target::ttnn::EltwiseOpWithFloatParams *EltwiseOp::params_as<tt::target::ttnn::EltwiseOpWithFloatParams>() const {
  return params_as_EltwiseOpWithFloatParams();
}
 
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);
  }
  void add_params_type(tt::target::ttnn::EltwiseOpParams params_type) {
    fbb_.AddElement<uint8_t>(EltwiseOp::VT_PARAMS_TYPE, static_cast<uint8_t>(params_type), 0);
  }
  void add_params(::flatbuffers::Offset<void> params) {
    fbb_.AddOffset(EltwiseOp::VT_PARAMS, params);
  }
  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,
    tt::target::ttnn::EltwiseOpParams params_type = tt::target::ttnn::EltwiseOpParams::NONE,
    ::flatbuffers::Offset<void> params = 0) {
  EltwiseOpBuilder builder_(_fbb);
  builder_.add_params(params);
  builder_.add_out(out);
  builder_.add_ins(ins);
  builder_.add_type(type);
  builder_.add_params_type(params_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,
    tt::target::ttnn::EltwiseOpParams params_type = tt::target::ttnn::EltwiseOpParams::NONE,
    ::flatbuffers::Offset<void> params = 0) {
  auto ins__ = ins ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::TensorRef>>(*ins) : 0;
  return tt::target::ttnn::CreateEltwiseOp(
      _fbb,
      type,
      ins__,
      out,
      params_type,
      params);
}
 
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_OUT = 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 *out() const {
    return GetPointer<const tt::target::TensorRef *>(VT_OUT);
  }
  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_OUT) &&
           verifier.VerifyTable(out()) &&
           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_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(EmbeddingOp::VT_OUT, out);
  }
  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> out = 0) {
  EmbeddingOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct EmbeddingOp::Traits {
  using type = EmbeddingOp;
  static auto constexpr Create = CreateEmbeddingOp;
};
 
struct EmbeddingBackwardOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmbeddingBackwardOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_IN_GRAD = 8,
    VT_DTYPE = 10,
    VT_MEMCFG = 12,
    VT_OUT = 14
  };
  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 *in_grad() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN_GRAD);
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  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_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_IN_GRAD) &&
           verifier.VerifyTable(in_grad()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EmbeddingBackwardOpBuilder {
  typedef EmbeddingBackwardOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::TensorRef> weight) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_WEIGHT, weight);
  }
  void add_in_grad(::flatbuffers::Offset<tt::target::TensorRef> in_grad) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_IN_GRAD, in_grad);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(EmbeddingBackwardOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_OUT, out);
  }
  explicit EmbeddingBackwardOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmbeddingBackwardOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmbeddingBackwardOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmbeddingBackwardOp> CreateEmbeddingBackwardOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> in_grad = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memcfg = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  EmbeddingBackwardOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_in_grad(in_grad);
  builder_.add_weight(weight);
  builder_.add_input(input);
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct EmbeddingBackwardOp::Traits {
  using type = EmbeddingBackwardOp;
  static auto constexpr Create = CreateEmbeddingBackwardOp;
};
 
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 RepeatOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RepeatOpBuilder 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<uint32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_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 RepeatOpBuilder {
  typedef RepeatOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(RepeatOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(RepeatOp::VT_OUT, out);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shape) {
    fbb_.AddOffset(RepeatOp::VT_SHAPE, shape);
  }
  explicit RepeatOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RepeatOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RepeatOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<RepeatOp> CreateRepeatOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> shape = 0) {
  RepeatOpBuilder builder_(_fbb);
  builder_.add_shape(shape);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct RepeatOp::Traits {
  using type = RepeatOp;
  static auto constexpr Create = CreateRepeatOp;
};
 
inline ::flatbuffers::Offset<RepeatOp> CreateRepeatOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    const std::vector<uint32_t> *shape = nullptr) {
  auto shape__ = shape ? _fbb.CreateVector<uint32_t>(*shape) : 0;
  return tt::target::ttnn::CreateRepeatOp(
      _fbb,
      in,
      out,
      shape__);
}
 
struct SliceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SliceOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_BEGINS = 8,
    VT_ENDS = 10,
    VT_STEP = 12
  };
  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<int64_t> *begins() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_BEGINS);
  }
  const ::flatbuffers::Vector<int64_t> *ends() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ENDS);
  }
  const ::flatbuffers::Vector<int64_t> *step() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_STEP);
  }
  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_BEGINS) &&
           verifier.VerifyVector(begins()) &&
           VerifyOffset(verifier, VT_ENDS) &&
           verifier.VerifyVector(ends()) &&
           VerifyOffset(verifier, VT_STEP) &&
           verifier.VerifyVector(step()) &&
           verifier.EndTable();
  }
};
 
struct SliceOpBuilder {
  typedef SliceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(SliceOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(SliceOp::VT_OUT, out);
  }
  void add_begins(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> begins) {
    fbb_.AddOffset(SliceOp::VT_BEGINS, begins);
  }
  void add_ends(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> ends) {
    fbb_.AddOffset(SliceOp::VT_ENDS, ends);
  }
  void add_step(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> step) {
    fbb_.AddOffset(SliceOp::VT_STEP, step);
  }
  explicit SliceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SliceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SliceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<SliceOp> CreateSliceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> begins = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> ends = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> step = 0) {
  SliceOpBuilder builder_(_fbb);
  builder_.add_step(step);
  builder_.add_ends(ends);
  builder_.add_begins(begins);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct SliceOp::Traits {
  using type = SliceOp;
  static auto constexpr Create = CreateSliceOp;
};
 
inline ::flatbuffers::Offset<SliceOp> CreateSliceOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    const std::vector<int64_t> *begins = nullptr,
    const std::vector<int64_t> *ends = nullptr,
    const std::vector<int64_t> *step = nullptr) {
  auto begins__ = begins ? _fbb.CreateVector<int64_t>(*begins) : 0;
  auto ends__ = ends ? _fbb.CreateVector<int64_t>(*ends) : 0;
  auto step__ = step ? _fbb.CreateVector<int64_t>(*step) : 0;
  return tt::target::ttnn::CreateSliceOp(
      _fbb,
      in,
      out,
      begins__,
      ends__,
      step__);
}
 
struct LinearOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LinearOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN0 = 4,
    VT_IN1 = 6,
    VT_BIAS = 8,
    VT_OUT = 10
  };
  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 *bias() const {
    return GetPointer<const tt::target::TensorRef *>(VT_BIAS);
  }
  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_BIAS) &&
           verifier.VerifyTable(bias()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct LinearOpBuilder {
  typedef LinearOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in0(::flatbuffers::Offset<tt::target::TensorRef> in0) {
    fbb_.AddOffset(LinearOp::VT_IN0, in0);
  }
  void add_in1(::flatbuffers::Offset<tt::target::TensorRef> in1) {
    fbb_.AddOffset(LinearOp::VT_IN1, in1);
  }
  void add_bias(::flatbuffers::Offset<tt::target::TensorRef> bias) {
    fbb_.AddOffset(LinearOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(LinearOp::VT_OUT, out);
  }
  explicit LinearOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LinearOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LinearOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LinearOp> CreateLinearOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in0 = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> in1 = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  LinearOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_bias(bias);
  builder_.add_in1(in1);
  builder_.add_in0(in0);
  return builder_.Finish();
}
 
struct LinearOp::Traits {
  using type = LinearOp;
  static auto constexpr Create = CreateLinearOp;
};
 
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 ConvTranspose2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConvTranspose2dOpBuilder 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_SIZE = 24,
    VT_STRIDE = 26,
    VT_PADDING = 28,
    VT_OUTPUT_PADDING = 30,
    VT_DILATION = 32,
    VT_GROUPS = 34
  };
  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);
  }
  const ::flatbuffers::Vector<int32_t> *kernel_size() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_KERNEL_SIZE);
  }
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  const ::flatbuffers::Vector<int32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *output_padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DILATION);
  }
  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) &&
           VerifyOffset(verifier, VT_KERNEL_SIZE) &&
           verifier.VerifyVector(kernel_size()) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_OUTPUT_PADDING) &&
           verifier.VerifyVector(output_padding()) &&
           VerifyOffset(verifier, VT_DILATION) &&
           verifier.VerifyVector(dilation()) &&
           VerifyField<uint32_t>(verifier, VT_GROUPS, 4) &&
           verifier.EndTable();
  }
};
 
struct ConvTranspose2dOpBuilder {
  typedef ConvTranspose2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::TensorRef> input) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::TensorRef> weight) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_WEIGHT, weight);
  }
  void add_bias(::flatbuffers::Offset<tt::target::TensorRef> bias) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_DEVICE, device);
  }
  void add_in_channels(uint32_t in_channels) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_IN_CHANNELS, in_channels, 0);
  }
  void add_out_channels(uint32_t out_channels) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_OUT_CHANNELS, out_channels, 0);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_kernel_size(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_KERNEL_SIZE, kernel_size);
  }
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_STRIDE, stride);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_PADDING, padding);
  }
  void add_output_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> output_padding) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_OUTPUT_PADDING, output_padding);
  }
  void add_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_DILATION, dilation);
  }
  void add_groups(uint32_t groups) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_GROUPS, groups, 0);
  }
  explicit ConvTranspose2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConvTranspose2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConvTranspose2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConvTranspose2dOp> CreateConvTranspose2dOp(
    ::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,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> output_padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation = 0,
    uint32_t groups = 0) {
  ConvTranspose2dOpBuilder builder_(_fbb);
  builder_.add_groups(groups);
  builder_.add_dilation(dilation);
  builder_.add_output_padding(output_padding);
  builder_.add_padding(padding);
  builder_.add_stride(stride);
  builder_.add_kernel_size(kernel_size);
  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 ConvTranspose2dOp::Traits {
  using type = ConvTranspose2dOp;
  static auto constexpr Create = CreateConvTranspose2dOp;
};
 
inline ::flatbuffers::Offset<ConvTranspose2dOp> CreateConvTranspose2dOpDirect(
    ::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,
    const std::vector<int32_t> *kernel_size = nullptr,
    const std::vector<int32_t> *stride = nullptr,
    const std::vector<int32_t> *padding = nullptr,
    const std::vector<int32_t> *output_padding = nullptr,
    const std::vector<int32_t> *dilation = nullptr,
    uint32_t groups = 0) {
  auto kernel_size__ = kernel_size ? _fbb.CreateVector<int32_t>(*kernel_size) : 0;
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
  auto output_padding__ = output_padding ? _fbb.CreateVector<int32_t>(*output_padding) : 0;
  auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
  return tt::target::ttnn::CreateConvTranspose2dOp(
      _fbb,
      input,
      weight,
      bias,
      out,
      device,
      in_channels,
      out_channels,
      batch_size,
      input_height,
      input_width,
      kernel_size__,
      stride__,
      padding__,
      output_padding__,
      dilation__,
      groups);
}
 
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 DeallocateOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DeallocateOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_FORCE = 6
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  bool force() const {
    return GetField<uint8_t>(VT_FORCE, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<uint8_t>(verifier, VT_FORCE, 1) &&
           verifier.EndTable();
  }
};
 
struct DeallocateOpBuilder {
  typedef DeallocateOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(DeallocateOp::VT_IN, in);
  }
  void add_force(bool force) {
    fbb_.AddElement<uint8_t>(DeallocateOp::VT_FORCE, static_cast<uint8_t>(force), 0);
  }
  explicit DeallocateOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DeallocateOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DeallocateOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DeallocateOp> CreateDeallocateOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    bool force = false) {
  DeallocateOpBuilder builder_(_fbb);
  builder_.add_in(in);
  builder_.add_force(force);
  return builder_.Finish();
}
 
struct DeallocateOp::Traits {
  using type = DeallocateOp;
  static auto constexpr Create = CreateDeallocateOp;
};
 
struct AllGatherOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AllGatherOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DEVICE = 8,
    VT_DIM = 10,
    VT_NUM_LINKS = 12
  };
  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 dim() const {
    return GetField<uint32_t>(VT_DIM, 0);
  }
  uint32_t num_links() const {
    return GetField<uint32_t>(VT_NUM_LINKS, 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_DIM, 4) &&
           VerifyField<uint32_t>(verifier, VT_NUM_LINKS, 4) &&
           verifier.EndTable();
  }
};
 
struct AllGatherOpBuilder {
  typedef AllGatherOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(AllGatherOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(AllGatherOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(AllGatherOp::VT_DEVICE, device);
  }
  void add_dim(uint32_t dim) {
    fbb_.AddElement<uint32_t>(AllGatherOp::VT_DIM, dim, 0);
  }
  void add_num_links(uint32_t num_links) {
    fbb_.AddElement<uint32_t>(AllGatherOp::VT_NUM_LINKS, num_links, 0);
  }
  explicit AllGatherOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AllGatherOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AllGatherOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<AllGatherOp> CreateAllGatherOp(
    ::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 dim = 0,
    uint32_t num_links = 0) {
  AllGatherOpBuilder builder_(_fbb);
  builder_.add_num_links(num_links);
  builder_.add_dim(dim);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct AllGatherOp::Traits {
  using type = AllGatherOp;
  static auto constexpr Create = CreateAllGatherOp;
};
 
struct PermuteOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PermuteOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_PERMUTATION = 6,
    VT_MEMORY_CONFIG = 8,
    VT_PAD_VALUE = 10,
    VT_OUT = 12
  };
  const tt::target::TensorRef *in() const {
    return GetPointer<const tt::target::TensorRef *>(VT_IN);
  }
  const ::flatbuffers::Vector<int64_t> *permutation() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PERMUTATION);
  }
  const tt::target::MemoryConfigDesc *memory_config() const {
    return GetPointer<const tt::target::MemoryConfigDesc *>(VT_MEMORY_CONFIG);
  }
  float pad_value() const {
    return GetField<float>(VT_PAD_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_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_PERMUTATION) &&
           verifier.VerifyVector(permutation()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyField<float>(verifier, VT_PAD_VALUE, 4) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct PermuteOpBuilder {
  typedef PermuteOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(PermuteOp::VT_IN, in);
  }
  void add_permutation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation) {
    fbb_.AddOffset(PermuteOp::VT_PERMUTATION, permutation);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::MemoryConfigDesc> memory_config) {
    fbb_.AddOffset(PermuteOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_pad_value(float pad_value) {
    fbb_.AddElement<float>(PermuteOp::VT_PAD_VALUE, pad_value, 0.0f);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(PermuteOp::VT_OUT, out);
  }
  explicit PermuteOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PermuteOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PermuteOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PermuteOp> CreatePermuteOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation = 0,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memory_config = 0,
    float pad_value = 0.0f,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  PermuteOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_pad_value(pad_value);
  builder_.add_memory_config(memory_config);
  builder_.add_permutation(permutation);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct PermuteOp::Traits {
  using type = PermuteOp;
  static auto constexpr Create = CreatePermuteOp;
};
 
inline ::flatbuffers::Offset<PermuteOp> CreatePermuteOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    const std::vector<int64_t> *permutation = nullptr,
    ::flatbuffers::Offset<tt::target::MemoryConfigDesc> memory_config = 0,
    float pad_value = 0.0f,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0) {
  auto permutation__ = permutation ? _fbb.CreateVector<int64_t>(*permutation) : 0;
  return tt::target::ttnn::CreatePermuteOp(
      _fbb,
      in,
      permutation__,
      memory_config,
      pad_value,
      out);
}
 
struct ReduceScatterOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReduceScatterOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DEVICE = 8,
    VT_SCATTER_SPLIT_DIM = 10,
    VT_MATH_OP = 12,
    VT_NUM_LINKS = 14
  };
  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 scatter_split_dim() const {
    return GetField<uint32_t>(VT_SCATTER_SPLIT_DIM, 0);
  }
  uint32_t math_op() const {
    return GetField<uint32_t>(VT_MATH_OP, 0);
  }
  uint32_t num_links() const {
    return GetField<uint32_t>(VT_NUM_LINKS, 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_SCATTER_SPLIT_DIM, 4) &&
           VerifyField<uint32_t>(verifier, VT_MATH_OP, 4) &&
           VerifyField<uint32_t>(verifier, VT_NUM_LINKS, 4) &&
           verifier.EndTable();
  }
};
 
struct ReduceScatterOpBuilder {
  typedef ReduceScatterOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(ReduceScatterOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(ReduceScatterOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ReduceScatterOp::VT_DEVICE, device);
  }
  void add_scatter_split_dim(uint32_t scatter_split_dim) {
    fbb_.AddElement<uint32_t>(ReduceScatterOp::VT_SCATTER_SPLIT_DIM, scatter_split_dim, 0);
  }
  void add_math_op(uint32_t math_op) {
    fbb_.AddElement<uint32_t>(ReduceScatterOp::VT_MATH_OP, math_op, 0);
  }
  void add_num_links(uint32_t num_links) {
    fbb_.AddElement<uint32_t>(ReduceScatterOp::VT_NUM_LINKS, num_links, 0);
  }
  explicit ReduceScatterOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReduceScatterOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReduceScatterOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReduceScatterOp> CreateReduceScatterOp(
    ::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 scatter_split_dim = 0,
    uint32_t math_op = 0,
    uint32_t num_links = 0) {
  ReduceScatterOpBuilder builder_(_fbb);
  builder_.add_num_links(num_links);
  builder_.add_math_op(math_op);
  builder_.add_scatter_split_dim(scatter_split_dim);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct ReduceScatterOp::Traits {
  using type = ReduceScatterOp;
  static auto constexpr Create = CreateReduceScatterOp;
};
 
struct MeshShardOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MeshShardOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DEVICE = 8,
    VT_SHARD_DIRECTION = 10,
    VT_SHARD_TYPE = 12,
    VT_SHARD_SHAPE = 14
  };
  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);
  }
  tt::target::MeshShardDirection shard_direction() const {
    return static_cast<tt::target::MeshShardDirection>(GetField<uint32_t>(VT_SHARD_DIRECTION, 0));
  }
  tt::target::MeshShardType shard_type() const {
    return static_cast<tt::target::MeshShardType>(GetField<uint32_t>(VT_SHARD_TYPE, 0));
  }
  const ::flatbuffers::Vector<int64_t> *shard_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHARD_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_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_SHARD_DIRECTION, 4) &&
           VerifyField<uint32_t>(verifier, VT_SHARD_TYPE, 4) &&
           VerifyOffset(verifier, VT_SHARD_SHAPE) &&
           verifier.VerifyVector(shard_shape()) &&
           verifier.EndTable();
  }
};
 
struct MeshShardOpBuilder {
  typedef MeshShardOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::TensorRef> in) {
    fbb_.AddOffset(MeshShardOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::TensorRef> out) {
    fbb_.AddOffset(MeshShardOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(MeshShardOp::VT_DEVICE, device);
  }
  void add_shard_direction(tt::target::MeshShardDirection shard_direction) {
    fbb_.AddElement<uint32_t>(MeshShardOp::VT_SHARD_DIRECTION, static_cast<uint32_t>(shard_direction), 0);
  }
  void add_shard_type(tt::target::MeshShardType shard_type) {
    fbb_.AddElement<uint32_t>(MeshShardOp::VT_SHARD_TYPE, static_cast<uint32_t>(shard_type), 0);
  }
  void add_shard_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shard_shape) {
    fbb_.AddOffset(MeshShardOp::VT_SHARD_SHAPE, shard_shape);
  }
  explicit MeshShardOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MeshShardOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MeshShardOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MeshShardOp> CreateMeshShardOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    tt::target::MeshShardDirection shard_direction = tt::target::MeshShardDirection::FullToShardShape,
    tt::target::MeshShardType shard_type = tt::target::MeshShardType::Manual,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shard_shape = 0) {
  MeshShardOpBuilder builder_(_fbb);
  builder_.add_shard_shape(shard_shape);
  builder_.add_shard_type(shard_type);
  builder_.add_shard_direction(shard_direction);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct MeshShardOp::Traits {
  using type = MeshShardOp;
  static auto constexpr Create = CreateMeshShardOp;
};
 
inline ::flatbuffers::Offset<MeshShardOp> CreateMeshShardOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    tt::target::MeshShardDirection shard_direction = tt::target::MeshShardDirection::FullToShardShape,
    tt::target::MeshShardType shard_type = tt::target::MeshShardType::Manual,
    const std::vector<int64_t> *shard_shape = nullptr) {
  auto shard_shape__ = shard_shape ? _fbb.CreateVector<int64_t>(*shard_shape) : 0;
  return tt::target::ttnn::CreateMeshShardOp(
      _fbb,
      in,
      out,
      device,
      shard_direction,
      shard_type,
      shard_shape__);
}
 
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,
    VT_LOC_INFO = 10
  };
  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::TypecastOp *type_as_TypecastOp() const {
    return type_type() == tt::target::ttnn::OpType::TypecastOp ? static_cast<const tt::target::ttnn::TypecastOp *>(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::OnesOp *type_as_OnesOp() const {
    return type_type() == tt::target::ttnn::OpType::OnesOp ? static_cast<const tt::target::ttnn::OnesOp *>(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::LinearOp *type_as_LinearOp() const {
    return type_type() == tt::target::ttnn::OpType::LinearOp ? static_cast<const tt::target::ttnn::LinearOp *>(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::EmbeddingBackwardOp *type_as_EmbeddingBackwardOp() const {
    return type_type() == tt::target::ttnn::OpType::EmbeddingBackwardOp ? static_cast<const tt::target::ttnn::EmbeddingBackwardOp *>(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::ConvTranspose2dOp *type_as_ConvTranspose2dOp() const {
    return type_type() == tt::target::ttnn::OpType::ConvTranspose2dOp ? static_cast<const tt::target::ttnn::ConvTranspose2dOp *>(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::SliceOp *type_as_SliceOp() const {
    return type_type() == tt::target::ttnn::OpType::SliceOp ? static_cast<const tt::target::ttnn::SliceOp *>(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::DeallocateOp *type_as_DeallocateOp() const {
    return type_type() == tt::target::ttnn::OpType::DeallocateOp ? static_cast<const tt::target::ttnn::DeallocateOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::AllGatherOp *type_as_AllGatherOp() const {
    return type_type() == tt::target::ttnn::OpType::AllGatherOp ? static_cast<const tt::target::ttnn::AllGatherOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ReduceScatterOp *type_as_ReduceScatterOp() const {
    return type_type() == tt::target::ttnn::OpType::ReduceScatterOp ? static_cast<const tt::target::ttnn::ReduceScatterOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::MeshShardOp *type_as_MeshShardOp() const {
    return type_type() == tt::target::ttnn::OpType::MeshShardOp ? static_cast<const tt::target::ttnn::MeshShardOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ArangeOp *type_as_ArangeOp() const {
    return type_type() == tt::target::ttnn::OpType::ArangeOp ? static_cast<const tt::target::ttnn::ArangeOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::UpdateCacheOp *type_as_UpdateCacheOp() const {
    return type_type() == tt::target::ttnn::OpType::UpdateCacheOp ? static_cast<const tt::target::ttnn::UpdateCacheOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::FillCacheOp *type_as_FillCacheOp() const {
    return type_type() == tt::target::ttnn::OpType::FillCacheOp ? static_cast<const tt::target::ttnn::FillCacheOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::PermuteOp *type_as_PermuteOp() const {
    return type_type() == tt::target::ttnn::OpType::PermuteOp ? static_cast<const tt::target::ttnn::PermuteOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::RepeatOp *type_as_RepeatOp() const {
    return type_type() == tt::target::ttnn::OpType::RepeatOp ? static_cast<const tt::target::ttnn::RepeatOp *>(type()) : nullptr;
  }
  const ::flatbuffers::String *debug_info() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DEBUG_INFO);
  }
  const ::flatbuffers::String *loc_info() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LOC_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()) &&
           VerifyOffset(verifier, VT_LOC_INFO) &&
           verifier.VerifyString(loc_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::TypecastOp *Operation::type_as<tt::target::ttnn::TypecastOp>() const {
  return type_as_TypecastOp();
}
 
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::OnesOp *Operation::type_as<tt::target::ttnn::OnesOp>() const {
  return type_as_OnesOp();
}
 
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::LinearOp *Operation::type_as<tt::target::ttnn::LinearOp>() const {
  return type_as_LinearOp();
}
 
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::EmbeddingBackwardOp *Operation::type_as<tt::target::ttnn::EmbeddingBackwardOp>() const {
  return type_as_EmbeddingBackwardOp();
}
 
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::ConvTranspose2dOp *Operation::type_as<tt::target::ttnn::ConvTranspose2dOp>() const {
  return type_as_ConvTranspose2dOp();
}
 
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::SliceOp *Operation::type_as<tt::target::ttnn::SliceOp>() const {
  return type_as_SliceOp();
}
 
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::DeallocateOp *Operation::type_as<tt::target::ttnn::DeallocateOp>() const {
  return type_as_DeallocateOp();
}
 
template<> inline const tt::target::ttnn::AllGatherOp *Operation::type_as<tt::target::ttnn::AllGatherOp>() const {
  return type_as_AllGatherOp();
}
 
template<> inline const tt::target::ttnn::ReduceScatterOp *Operation::type_as<tt::target::ttnn::ReduceScatterOp>() const {
  return type_as_ReduceScatterOp();
}
 
template<> inline const tt::target::ttnn::MeshShardOp *Operation::type_as<tt::target::ttnn::MeshShardOp>() const {
  return type_as_MeshShardOp();
}
 
template<> inline const tt::target::ttnn::ArangeOp *Operation::type_as<tt::target::ttnn::ArangeOp>() const {
  return type_as_ArangeOp();
}
 
template<> inline const tt::target::ttnn::UpdateCacheOp *Operation::type_as<tt::target::ttnn::UpdateCacheOp>() const {
  return type_as_UpdateCacheOp();
}
 
template<> inline const tt::target::ttnn::FillCacheOp *Operation::type_as<tt::target::ttnn::FillCacheOp>() const {
  return type_as_FillCacheOp();
}
 
template<> inline const tt::target::ttnn::PermuteOp *Operation::type_as<tt::target::ttnn::PermuteOp>() const {
  return type_as_PermuteOp();
}
 
template<> inline const tt::target::ttnn::RepeatOp *Operation::type_as<tt::target::ttnn::RepeatOp>() const {
  return type_as_RepeatOp();
}
 
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);
  }
  void add_loc_info(::flatbuffers::Offset<::flatbuffers::String> loc_info) {
    fbb_.AddOffset(Operation::VT_LOC_INFO, loc_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,
    ::flatbuffers::Offset<::flatbuffers::String> loc_info = 0) {
  OperationBuilder builder_(_fbb);
  builder_.add_loc_info(loc_info);
  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,
    const char *loc_info = nullptr) {
  auto debug_info__ = debug_info ? _fbb.CreateString(debug_info) : 0;
  auto loc_info__ = loc_info ? _fbb.CreateString(loc_info) : 0;
  return tt::target::ttnn::CreateOperation(
      _fbb,
      type_type,
      type,
      debug_info__,
      loc_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 VerifyEltwiseOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseOpParams type) {
  switch (type) {
    case EltwiseOpParams::NONE: {
      return true;
    }
    case EltwiseOpParams::ClampOpParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ClampOpParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case EltwiseOpParams::EltwiseOpWithFloatParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseOpWithFloatParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyEltwiseOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseOpParams> *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 (!VerifyEltwiseOpParams(
        verifier,  values->Get(i), types->GetEnum<EltwiseOpParams>(i))) {
      return false;
    }
  }
  return true;
}
 
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::TypecastOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::TypecastOp *>(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::OnesOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::OnesOp *>(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::LinearOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::LinearOp *>(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::EmbeddingBackwardOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmbeddingBackwardOp *>(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::ConvTranspose2dOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ConvTranspose2dOp *>(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::SliceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::SliceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::MaxPool2dOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MaxPool2dOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::DeallocateOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::DeallocateOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::AllGatherOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::AllGatherOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReduceScatterOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReduceScatterOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::MeshShardOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MeshShardOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ArangeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ArangeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::UpdateCacheOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::UpdateCacheOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FillCacheOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FillCacheOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::PermuteOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PermuteOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::RepeatOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::RepeatOp *>(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_