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 "ttmlir/Target/Common/debug_info_generated.h"
#include "ttmlir/Target/Common/types_generated.h"
#include "ttmlir/Target/TTNN/operations/ccl_generated.h"
#include "ttmlir/Target/TTNN/operations/conv_generated.h"
#include "ttmlir/Target/TTNN/operations/cpu_generated.h"
#include "ttmlir/Target/TTNN/operations/creation_generated.h"
#include "ttmlir/Target/TTNN/operations/data_movement_generated.h"
#include "ttmlir/Target/TTNN/operations/deallocate_generated.h"
#include "ttmlir/Target/TTNN/operations/eltwise_generated.h"
#include "ttmlir/Target/TTNN/operations/embedding_generated.h"
#include "ttmlir/Target/TTNN/operations/get_device_generated.h"
#include "ttmlir/Target/TTNN/operations/kv_cache_generated.h"
#include "ttmlir/Target/TTNN/operations/layout_generated.h"
#include "ttmlir/Target/TTNN/operations/load_cached_generated.h"
#include "ttmlir/Target/TTNN/operations/matmul_generated.h"
#include "ttmlir/Target/TTNN/operations/moreh_cumsum_generated.h"
#include "ttmlir/Target/TTNN/operations/pool_generated.h"
#include "ttmlir/Target/TTNN/operations/reduction_generated.h"
#include "ttmlir/Target/TTNN/operations/softmax_generated.h"
#include "ttmlir/Target/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct Operation;
struct OperationBuilder;
 
struct Program;
struct ProgramBuilder;
 
enum class OpType : uint8_t {
  NONE = 0,
  AllGatherOp = 1,
  CollectivePermuteOp = 2,
  MeshShardOp = 3,
  ReduceScatterOp = 4,
  GetDeviceOp = 5,
  PrepareConv2dWeightsOp = 6,
  Conv2dOp = 7,
  ConvTranspose2dOp = 8,
  CpuOp = 9,
  ArangeOp = 10,
  ConstantOp = 11,
  EmptyOp = 12,
  FullOp = 13,
  NamedFullOp = 14,
  ConcatOp = 15,
  PadOp = 16,
  PermuteOp = 17,
  RepeatInterleaveOp = 18,
  RepeatOp = 19,
  ReshapeOp = 20,
  SliceOp = 21,
  TransposeOp = 22,
  DeallocateOp = 23,
  EltwiseBinaryOp = 24,
  EltwiseBinaryCompositeOp = 25,
  EltwiseTernaryWhereOp = 26,
  EltwiseQuantizationOp = 27,
  EltwiseUnaryOp = 28,
  EltwiseUnaryCompositeOp = 29,
  EmbeddingBackwardOp = 30,
  EmbeddingOp = 31,
  FillCacheOp = 32,
  UpdateCacheOp = 33,
  FromDeviceOp = 34,
  ToDeviceOp = 35,
  ToDTypeOp = 36,
  ToLayoutOp = 37,
  ToMemoryConfigOp = 38,
  TypecastOp = 39,
  LinearOp = 40,
  MatmulOp = 41,
  MorehCumSumOp = 42,
  SoftmaxOp = 43,
  Pool2dOp = 44,
  UpsampleOp = 45,
  ReductionArgMaxOp = 46,
  ReductionOp = 47,
  ReductionProdOp = 48,
  LoadCachedOp = 49,
  MIN = NONE,
  MAX = LoadCachedOp
};
 
inline const OpType (&EnumValuesOpType())[50] {
  static const OpType values[] = {
    OpType::NONE,
    OpType::AllGatherOp,
    OpType::CollectivePermuteOp,
    OpType::MeshShardOp,
    OpType::ReduceScatterOp,
    OpType::GetDeviceOp,
    OpType::PrepareConv2dWeightsOp,
    OpType::Conv2dOp,
    OpType::ConvTranspose2dOp,
    OpType::CpuOp,
    OpType::ArangeOp,
    OpType::ConstantOp,
    OpType::EmptyOp,
    OpType::FullOp,
    OpType::NamedFullOp,
    OpType::ConcatOp,
    OpType::PadOp,
    OpType::PermuteOp,
    OpType::RepeatInterleaveOp,
    OpType::RepeatOp,
    OpType::ReshapeOp,
    OpType::SliceOp,
    OpType::TransposeOp,
    OpType::DeallocateOp,
    OpType::EltwiseBinaryOp,
    OpType::EltwiseBinaryCompositeOp,
    OpType::EltwiseTernaryWhereOp,
    OpType::EltwiseQuantizationOp,
    OpType::EltwiseUnaryOp,
    OpType::EltwiseUnaryCompositeOp,
    OpType::EmbeddingBackwardOp,
    OpType::EmbeddingOp,
    OpType::FillCacheOp,
    OpType::UpdateCacheOp,
    OpType::FromDeviceOp,
    OpType::ToDeviceOp,
    OpType::ToDTypeOp,
    OpType::ToLayoutOp,
    OpType::ToMemoryConfigOp,
    OpType::TypecastOp,
    OpType::LinearOp,
    OpType::MatmulOp,
    OpType::MorehCumSumOp,
    OpType::SoftmaxOp,
    OpType::Pool2dOp,
    OpType::UpsampleOp,
    OpType::ReductionArgMaxOp,
    OpType::ReductionOp,
    OpType::ReductionProdOp,
    OpType::LoadCachedOp
  };
  return values;
}
 
inline const char * const *EnumNamesOpType() {
  static const char * const names[51] = {
    "NONE",
    "AllGatherOp",
    "CollectivePermuteOp",
    "MeshShardOp",
    "ReduceScatterOp",
    "GetDeviceOp",
    "PrepareConv2dWeightsOp",
    "Conv2dOp",
    "ConvTranspose2dOp",
    "CpuOp",
    "ArangeOp",
    "ConstantOp",
    "EmptyOp",
    "FullOp",
    "NamedFullOp",
    "ConcatOp",
    "PadOp",
    "PermuteOp",
    "RepeatInterleaveOp",
    "RepeatOp",
    "ReshapeOp",
    "SliceOp",
    "TransposeOp",
    "DeallocateOp",
    "EltwiseBinaryOp",
    "EltwiseBinaryCompositeOp",
    "EltwiseTernaryWhereOp",
    "EltwiseQuantizationOp",
    "EltwiseUnaryOp",
    "EltwiseUnaryCompositeOp",
    "EmbeddingBackwardOp",
    "EmbeddingOp",
    "FillCacheOp",
    "UpdateCacheOp",
    "FromDeviceOp",
    "ToDeviceOp",
    "ToDTypeOp",
    "ToLayoutOp",
    "ToMemoryConfigOp",
    "TypecastOp",
    "LinearOp",
    "MatmulOp",
    "MorehCumSumOp",
    "SoftmaxOp",
    "Pool2dOp",
    "UpsampleOp",
    "ReductionArgMaxOp",
    "ReductionOp",
    "ReductionProdOp",
    "LoadCachedOp",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameOpType(OpType e) {
  if (::flatbuffers::IsOutRange(e, OpType::NONE, OpType::LoadCachedOp)) 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::AllGatherOp> {
  static const OpType enum_value = OpType::AllGatherOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::CollectivePermuteOp> {
  static const OpType enum_value = OpType::CollectivePermuteOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::MeshShardOp> {
  static const OpType enum_value = OpType::MeshShardOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReduceScatterOp> {
  static const OpType enum_value = OpType::ReduceScatterOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::GetDeviceOp> {
  static const OpType enum_value = OpType::GetDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::PrepareConv2dWeightsOp> {
  static const OpType enum_value = OpType::PrepareConv2dWeightsOp;
};
 
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::CpuOp> {
  static const OpType enum_value = OpType::CpuOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ArangeOp> {
  static const OpType enum_value = OpType::ArangeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ConstantOp> {
  static const OpType enum_value = OpType::ConstantOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EmptyOp> {
  static const OpType enum_value = OpType::EmptyOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FullOp> {
  static const OpType enum_value = OpType::FullOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::NamedFullOp> {
  static const OpType enum_value = OpType::NamedFullOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ConcatOp> {
  static const OpType enum_value = OpType::ConcatOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::PadOp> {
  static const OpType enum_value = OpType::PadOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::PermuteOp> {
  static const OpType enum_value = OpType::PermuteOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::RepeatInterleaveOp> {
  static const OpType enum_value = OpType::RepeatInterleaveOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::RepeatOp> {
  static const OpType enum_value = OpType::RepeatOp;
};
 
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::TransposeOp> {
  static const OpType enum_value = OpType::TransposeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::DeallocateOp> {
  static const OpType enum_value = OpType::DeallocateOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseBinaryOp> {
  static const OpType enum_value = OpType::EltwiseBinaryOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseBinaryCompositeOp> {
  static const OpType enum_value = OpType::EltwiseBinaryCompositeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseTernaryWhereOp> {
  static const OpType enum_value = OpType::EltwiseTernaryWhereOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseQuantizationOp> {
  static const OpType enum_value = OpType::EltwiseQuantizationOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseUnaryOp> {
  static const OpType enum_value = OpType::EltwiseUnaryOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EltwiseUnaryCompositeOp> {
  static const OpType enum_value = OpType::EltwiseUnaryCompositeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EmbeddingBackwardOp> {
  static const OpType enum_value = OpType::EmbeddingBackwardOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::EmbeddingOp> {
  static const OpType enum_value = OpType::EmbeddingOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FillCacheOp> {
  static const OpType enum_value = OpType::FillCacheOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::UpdateCacheOp> {
  static const OpType enum_value = OpType::UpdateCacheOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::FromDeviceOp> {
  static const OpType enum_value = OpType::FromDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToDeviceOp> {
  static const OpType enum_value = OpType::ToDeviceOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToDTypeOp> {
  static const OpType enum_value = OpType::ToDTypeOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToLayoutOp> {
  static const OpType enum_value = OpType::ToLayoutOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ToMemoryConfigOp> {
  static const OpType enum_value = OpType::ToMemoryConfigOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::TypecastOp> {
  static const OpType enum_value = OpType::TypecastOp;
};
 
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::MorehCumSumOp> {
  static const OpType enum_value = OpType::MorehCumSumOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::SoftmaxOp> {
  static const OpType enum_value = OpType::SoftmaxOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::Pool2dOp> {
  static const OpType enum_value = OpType::Pool2dOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::UpsampleOp> {
  static const OpType enum_value = OpType::UpsampleOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReductionArgMaxOp> {
  static const OpType enum_value = OpType::ReductionArgMaxOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReductionOp> {
  static const OpType enum_value = OpType::ReductionOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::ReductionProdOp> {
  static const OpType enum_value = OpType::ReductionProdOp;
};
 
template<> struct OpTypeTraits<tt::target::ttnn::LoadCachedOp> {
  static const OpType enum_value = OpType::LoadCachedOp;
};
 
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 Operation FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef OperationBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.Operation";
  }
  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::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::CollectivePermuteOp *type_as_CollectivePermuteOp() const {
    return type_type() == tt::target::ttnn::OpType::CollectivePermuteOp ? static_cast<const tt::target::ttnn::CollectivePermuteOp *>(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::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::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::PrepareConv2dWeightsOp *type_as_PrepareConv2dWeightsOp() const {
    return type_type() == tt::target::ttnn::OpType::PrepareConv2dWeightsOp ? static_cast<const tt::target::ttnn::PrepareConv2dWeightsOp *>(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::CpuOp *type_as_CpuOp() const {
    return type_type() == tt::target::ttnn::OpType::CpuOp ? static_cast<const tt::target::ttnn::CpuOp *>(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::ConstantOp *type_as_ConstantOp() const {
    return type_type() == tt::target::ttnn::OpType::ConstantOp ? static_cast<const tt::target::ttnn::ConstantOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EmptyOp *type_as_EmptyOp() const {
    return type_type() == tt::target::ttnn::OpType::EmptyOp ? static_cast<const tt::target::ttnn::EmptyOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::FullOp *type_as_FullOp() const {
    return type_type() == tt::target::ttnn::OpType::FullOp ? static_cast<const tt::target::ttnn::FullOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::NamedFullOp *type_as_NamedFullOp() const {
    return type_type() == tt::target::ttnn::OpType::NamedFullOp ? static_cast<const tt::target::ttnn::NamedFullOp *>(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::PadOp *type_as_PadOp() const {
    return type_type() == tt::target::ttnn::OpType::PadOp ? static_cast<const tt::target::ttnn::PadOp *>(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::RepeatInterleaveOp *type_as_RepeatInterleaveOp() const {
    return type_type() == tt::target::ttnn::OpType::RepeatInterleaveOp ? static_cast<const tt::target::ttnn::RepeatInterleaveOp *>(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 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::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::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::EltwiseBinaryOp *type_as_EltwiseBinaryOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseBinaryOp ? static_cast<const tt::target::ttnn::EltwiseBinaryOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseBinaryCompositeOp *type_as_EltwiseBinaryCompositeOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseBinaryCompositeOp ? static_cast<const tt::target::ttnn::EltwiseBinaryCompositeOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseTernaryWhereOp *type_as_EltwiseTernaryWhereOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseTernaryWhereOp ? static_cast<const tt::target::ttnn::EltwiseTernaryWhereOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseQuantizationOp *type_as_EltwiseQuantizationOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseQuantizationOp ? static_cast<const tt::target::ttnn::EltwiseQuantizationOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseUnaryOp *type_as_EltwiseUnaryOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseUnaryOp ? static_cast<const tt::target::ttnn::EltwiseUnaryOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::EltwiseUnaryCompositeOp *type_as_EltwiseUnaryCompositeOp() const {
    return type_type() == tt::target::ttnn::OpType::EltwiseUnaryCompositeOp ? static_cast<const tt::target::ttnn::EltwiseUnaryCompositeOp *>(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::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::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::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::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::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::ToDTypeOp *type_as_ToDTypeOp() const {
    return type_type() == tt::target::ttnn::OpType::ToDTypeOp ? static_cast<const tt::target::ttnn::ToDTypeOp *>(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::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::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::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::MorehCumSumOp *type_as_MorehCumSumOp() const {
    return type_type() == tt::target::ttnn::OpType::MorehCumSumOp ? static_cast<const tt::target::ttnn::MorehCumSumOp *>(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::Pool2dOp *type_as_Pool2dOp() const {
    return type_type() == tt::target::ttnn::OpType::Pool2dOp ? static_cast<const tt::target::ttnn::Pool2dOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::UpsampleOp *type_as_UpsampleOp() const {
    return type_type() == tt::target::ttnn::OpType::UpsampleOp ? static_cast<const tt::target::ttnn::UpsampleOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::ReductionArgMaxOp *type_as_ReductionArgMaxOp() const {
    return type_type() == tt::target::ttnn::OpType::ReductionArgMaxOp ? static_cast<const tt::target::ttnn::ReductionArgMaxOp *>(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::ReductionProdOp *type_as_ReductionProdOp() const {
    return type_type() == tt::target::ttnn::OpType::ReductionProdOp ? static_cast<const tt::target::ttnn::ReductionProdOp *>(type()) : nullptr;
  }
  const tt::target::ttnn::LoadCachedOp *type_as_LoadCachedOp() const {
    return type_type() == tt::target::ttnn::OpType::LoadCachedOp ? static_cast<const tt::target::ttnn::LoadCachedOp *>(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::AllGatherOp *Operation::type_as<tt::target::ttnn::AllGatherOp>() const {
  return type_as_AllGatherOp();
}
 
template<> inline const tt::target::ttnn::CollectivePermuteOp *Operation::type_as<tt::target::ttnn::CollectivePermuteOp>() const {
  return type_as_CollectivePermuteOp();
}
 
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::ReduceScatterOp *Operation::type_as<tt::target::ttnn::ReduceScatterOp>() const {
  return type_as_ReduceScatterOp();
}
 
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::PrepareConv2dWeightsOp *Operation::type_as<tt::target::ttnn::PrepareConv2dWeightsOp>() const {
  return type_as_PrepareConv2dWeightsOp();
}
 
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::CpuOp *Operation::type_as<tt::target::ttnn::CpuOp>() const {
  return type_as_CpuOp();
}
 
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::ConstantOp *Operation::type_as<tt::target::ttnn::ConstantOp>() const {
  return type_as_ConstantOp();
}
 
template<> inline const tt::target::ttnn::EmptyOp *Operation::type_as<tt::target::ttnn::EmptyOp>() const {
  return type_as_EmptyOp();
}
 
template<> inline const tt::target::ttnn::FullOp *Operation::type_as<tt::target::ttnn::FullOp>() const {
  return type_as_FullOp();
}
 
template<> inline const tt::target::ttnn::NamedFullOp *Operation::type_as<tt::target::ttnn::NamedFullOp>() const {
  return type_as_NamedFullOp();
}
 
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::PadOp *Operation::type_as<tt::target::ttnn::PadOp>() const {
  return type_as_PadOp();
}
 
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::RepeatInterleaveOp *Operation::type_as<tt::target::ttnn::RepeatInterleaveOp>() const {
  return type_as_RepeatInterleaveOp();
}
 
template<> inline const tt::target::ttnn::RepeatOp *Operation::type_as<tt::target::ttnn::RepeatOp>() const {
  return type_as_RepeatOp();
}
 
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::TransposeOp *Operation::type_as<tt::target::ttnn::TransposeOp>() const {
  return type_as_TransposeOp();
}
 
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::EltwiseBinaryOp *Operation::type_as<tt::target::ttnn::EltwiseBinaryOp>() const {
  return type_as_EltwiseBinaryOp();
}
 
template<> inline const tt::target::ttnn::EltwiseBinaryCompositeOp *Operation::type_as<tt::target::ttnn::EltwiseBinaryCompositeOp>() const {
  return type_as_EltwiseBinaryCompositeOp();
}
 
template<> inline const tt::target::ttnn::EltwiseTernaryWhereOp *Operation::type_as<tt::target::ttnn::EltwiseTernaryWhereOp>() const {
  return type_as_EltwiseTernaryWhereOp();
}
 
template<> inline const tt::target::ttnn::EltwiseQuantizationOp *Operation::type_as<tt::target::ttnn::EltwiseQuantizationOp>() const {
  return type_as_EltwiseQuantizationOp();
}
 
template<> inline const tt::target::ttnn::EltwiseUnaryOp *Operation::type_as<tt::target::ttnn::EltwiseUnaryOp>() const {
  return type_as_EltwiseUnaryOp();
}
 
template<> inline const tt::target::ttnn::EltwiseUnaryCompositeOp *Operation::type_as<tt::target::ttnn::EltwiseUnaryCompositeOp>() const {
  return type_as_EltwiseUnaryCompositeOp();
}
 
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::EmbeddingOp *Operation::type_as<tt::target::ttnn::EmbeddingOp>() const {
  return type_as_EmbeddingOp();
}
 
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::UpdateCacheOp *Operation::type_as<tt::target::ttnn::UpdateCacheOp>() const {
  return type_as_UpdateCacheOp();
}
 
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::ToDeviceOp *Operation::type_as<tt::target::ttnn::ToDeviceOp>() const {
  return type_as_ToDeviceOp();
}
 
template<> inline const tt::target::ttnn::ToDTypeOp *Operation::type_as<tt::target::ttnn::ToDTypeOp>() const {
  return type_as_ToDTypeOp();
}
 
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::ToMemoryConfigOp *Operation::type_as<tt::target::ttnn::ToMemoryConfigOp>() const {
  return type_as_ToMemoryConfigOp();
}
 
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::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::MorehCumSumOp *Operation::type_as<tt::target::ttnn::MorehCumSumOp>() const {
  return type_as_MorehCumSumOp();
}
 
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::Pool2dOp *Operation::type_as<tt::target::ttnn::Pool2dOp>() const {
  return type_as_Pool2dOp();
}
 
template<> inline const tt::target::ttnn::UpsampleOp *Operation::type_as<tt::target::ttnn::UpsampleOp>() const {
  return type_as_UpsampleOp();
}
 
template<> inline const tt::target::ttnn::ReductionArgMaxOp *Operation::type_as<tt::target::ttnn::ReductionArgMaxOp>() const {
  return type_as_ReductionArgMaxOp();
}
 
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::ReductionProdOp *Operation::type_as<tt::target::ttnn::ReductionProdOp>() const {
  return type_as_ReductionProdOp();
}
 
template<> inline const tt::target::ttnn::LoadCachedOp *Operation::type_as<tt::target::ttnn::LoadCachedOp>() const {
  return type_as_LoadCachedOp();
}
 
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;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.Program";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_INPUTS = 6,
    VT_OUTPUTS = 8,
    VT_OPERATIONS = 10,
    VT_DYLIBS = 12,
    VT_DEBUG_INFO = 14
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::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 ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::DynamicLib>> *dylibs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::DynamicLib>> *>(VT_DYLIBS);
  }
  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_DYLIBS) &&
           verifier.VerifyVector(dylibs()) &&
           verifier.VerifyVectorOfTables(dylibs()) &&
           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::ttnn::TensorRef>>> inputs) {
    fbb_.AddOffset(Program::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::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_dylibs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::DynamicLib>>> dylibs) {
    fbb_.AddOffset(Program::VT_DYLIBS, dylibs);
  }
  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::ttnn::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> outputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::Operation>>> operations = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::DynamicLib>>> dylibs = 0,
    ::flatbuffers::Offset<tt::target::DebugInfo> debug_info = 0) {
  ProgramBuilder builder_(_fbb);
  builder_.add_debug_info(debug_info);
  builder_.add_dylibs(dylibs);
  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::ttnn::TensorRef>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::Operation>> *operations = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::DynamicLib>> *dylibs = 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::ttnn::TensorRef>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*outputs) : 0;
  auto operations__ = operations ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::Operation>>(*operations) : 0;
  auto dylibs__ = dylibs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::DynamicLib>>(*dylibs) : 0;
  return tt::target::ttnn::CreateProgram(
      _fbb,
      name__,
      inputs__,
      outputs__,
      operations__,
      dylibs__,
      debug_info);
}
 
inline bool VerifyOpType(::flatbuffers::Verifier &verifier, const void *obj, OpType type) {
  switch (type) {
    case OpType::NONE: {
      return true;
    }
    case OpType::AllGatherOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::AllGatherOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::CollectivePermuteOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::CollectivePermuteOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::MeshShardOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MeshShardOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReduceScatterOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReduceScatterOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::GetDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::GetDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::PrepareConv2dWeightsOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PrepareConv2dWeightsOp *>(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::CpuOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::CpuOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ArangeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ArangeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ConstantOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ConstantOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EmptyOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmptyOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FullOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FullOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::NamedFullOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::NamedFullOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ConcatOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ConcatOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::PadOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PadOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::PermuteOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PermuteOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::RepeatInterleaveOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::RepeatInterleaveOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::RepeatOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::RepeatOp *>(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::TransposeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::TransposeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::DeallocateOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::DeallocateOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseBinaryOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseBinaryOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseBinaryCompositeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseBinaryCompositeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseTernaryWhereOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseTernaryWhereOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseQuantizationOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseQuantizationOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseUnaryOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseUnaryOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EltwiseUnaryCompositeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseUnaryCompositeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EmbeddingBackwardOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmbeddingBackwardOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::EmbeddingOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EmbeddingOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FillCacheOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FillCacheOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::UpdateCacheOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::UpdateCacheOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::FromDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::FromDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToDeviceOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToDeviceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToDTypeOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToDTypeOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToLayoutOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToLayoutOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ToMemoryConfigOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ToMemoryConfigOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::TypecastOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::TypecastOp *>(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::MorehCumSumOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MorehCumSumOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::SoftmaxOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::SoftmaxOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::Pool2dOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::Pool2dOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::UpsampleOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::UpsampleOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReductionArgMaxOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReductionArgMaxOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReductionOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReductionOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::ReductionProdOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReductionProdOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case OpType::LoadCachedOp: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::LoadCachedOp *>(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_