types_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_TYPES_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_TYPES_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/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct CoreCoord;
 
struct CoreRange;
 
struct CoreRangeSet;
struct CoreRangeSetBuilder;
 
struct ReplicateTensor;
struct ReplicateTensorBuilder;
 
struct ShardTensor;
struct ShardTensorBuilder;
 
struct ShardTensor2D;
struct ShardTensor2DBuilder;
 
struct AllGatherTensor;
struct AllGatherTensorBuilder;
 
struct DistributionStrategy;
struct DistributionStrategyBuilder;
 
struct ShardSpec;
struct ShardSpecBuilder;
 
struct MemoryConfig;
struct MemoryConfigBuilder;
 
struct MemoryDesc;
struct MemoryDescBuilder;
 
struct LayoutDesc;
struct LayoutDescBuilder;
 
struct TensorDesc;
struct TensorDescBuilder;
 
struct TensorRef;
struct TensorRefBuilder;
 
enum class TensorMemoryLayout : uint16_t {
  Interleaved = 0,
  HeightSharded = 1,
  WidthSharded = 2,
  BlockSharded = 3,
  MIN = Interleaved,
  MAX = BlockSharded
};
 
inline const TensorMemoryLayout (&EnumValuesTensorMemoryLayout())[4] {
  static const TensorMemoryLayout values[] = {
    TensorMemoryLayout::Interleaved,
    TensorMemoryLayout::HeightSharded,
    TensorMemoryLayout::WidthSharded,
    TensorMemoryLayout::BlockSharded
  };
  return values;
}
 
inline const char * const *EnumNamesTensorMemoryLayout() {
  static const char * const names[5] = {
    "Interleaved",
    "HeightSharded",
    "WidthSharded",
    "BlockSharded",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameTensorMemoryLayout(TensorMemoryLayout e) {
  if (::flatbuffers::IsOutRange(e, TensorMemoryLayout::Interleaved, TensorMemoryLayout::BlockSharded)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTensorMemoryLayout()[index];
}
 
enum class StorageType : uint16_t {
  Host = 0,
  Device = 1,
  MultiDeviceHost = 2,
  MIN = Host,
  MAX = MultiDeviceHost
};
 
inline const StorageType (&EnumValuesStorageType())[3] {
  static const StorageType values[] = {
    StorageType::Host,
    StorageType::Device,
    StorageType::MultiDeviceHost
  };
  return values;
}
 
inline const char * const *EnumNamesStorageType() {
  static const char * const names[4] = {
    "Host",
    "Device",
    "MultiDeviceHost",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameStorageType(StorageType e) {
  if (::flatbuffers::IsOutRange(e, StorageType::Host, StorageType::MultiDeviceHost)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesStorageType()[index];
}
 
enum class MeshShardDirection : uint32_t {
  FullToShardShape = 0,
  ShardToFullShape = 1,
  MIN = FullToShardShape,
  MAX = ShardToFullShape
};
 
inline const MeshShardDirection (&EnumValuesMeshShardDirection())[2] {
  static const MeshShardDirection values[] = {
    MeshShardDirection::FullToShardShape,
    MeshShardDirection::ShardToFullShape
  };
  return values;
}
 
inline const char * const *EnumNamesMeshShardDirection() {
  static const char * const names[3] = {
    "FullToShardShape",
    "ShardToFullShape",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMeshShardDirection(MeshShardDirection e) {
  if (::flatbuffers::IsOutRange(e, MeshShardDirection::FullToShardShape, MeshShardDirection::ShardToFullShape)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMeshShardDirection()[index];
}
 
enum class MeshShardType : uint32_t {
  Identity = 0,
  Replicate = 1,
  Maximal = 2,
  Devices = 3,
  MIN = Identity,
  MAX = Devices
};
 
inline const MeshShardType (&EnumValuesMeshShardType())[4] {
  static const MeshShardType values[] = {
    MeshShardType::Identity,
    MeshShardType::Replicate,
    MeshShardType::Maximal,
    MeshShardType::Devices
  };
  return values;
}
 
inline const char * const *EnumNamesMeshShardType() {
  static const char * const names[5] = {
    "Identity",
    "Replicate",
    "Maximal",
    "Devices",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMeshShardType(MeshShardType e) {
  if (::flatbuffers::IsOutRange(e, MeshShardType::Identity, MeshShardType::Devices)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMeshShardType()[index];
}
 
enum class ShardOrientation : uint32_t {
  RowMajor = 0,
  ColMajor = 1,
  MIN = RowMajor,
  MAX = ColMajor
};
 
inline const ShardOrientation (&EnumValuesShardOrientation())[2] {
  static const ShardOrientation values[] = {
    ShardOrientation::RowMajor,
    ShardOrientation::ColMajor
  };
  return values;
}
 
inline const char * const *EnumNamesShardOrientation() {
  static const char * const names[3] = {
    "RowMajor",
    "ColMajor",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameShardOrientation(ShardOrientation e) {
  if (::flatbuffers::IsOutRange(e, ShardOrientation::RowMajor, ShardOrientation::ColMajor)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesShardOrientation()[index];
}
 
enum class ShardMode : uint32_t {
  Physical = 0,
  Logical = 1,
  MIN = Physical,
  MAX = Logical
};
 
inline const ShardMode (&EnumValuesShardMode())[2] {
  static const ShardMode values[] = {
    ShardMode::Physical,
    ShardMode::Logical
  };
  return values;
}
 
inline const char * const *EnumNamesShardMode() {
  static const char * const names[3] = {
    "Physical",
    "Logical",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameShardMode(ShardMode e) {
  if (::flatbuffers::IsOutRange(e, ShardMode::Physical, ShardMode::Logical)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesShardMode()[index];
}
 
enum class DistributedTensorConfig : uint8_t {
  NONE = 0,
  ReplicateTensor = 1,
  ShardTensor = 2,
  ShardTensor2D = 3,
  AllGatherTensor = 4,
  MIN = NONE,
  MAX = AllGatherTensor
};
 
inline const DistributedTensorConfig (&EnumValuesDistributedTensorConfig())[5] {
  static const DistributedTensorConfig values[] = {
    DistributedTensorConfig::NONE,
    DistributedTensorConfig::ReplicateTensor,
    DistributedTensorConfig::ShardTensor,
    DistributedTensorConfig::ShardTensor2D,
    DistributedTensorConfig::AllGatherTensor
  };
  return values;
}
 
inline const char * const *EnumNamesDistributedTensorConfig() {
  static const char * const names[6] = {
    "NONE",
    "ReplicateTensor",
    "ShardTensor",
    "ShardTensor2D",
    "AllGatherTensor",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameDistributedTensorConfig(DistributedTensorConfig e) {
  if (::flatbuffers::IsOutRange(e, DistributedTensorConfig::NONE, DistributedTensorConfig::AllGatherTensor)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDistributedTensorConfig()[index];
}
 
template<typename T> struct DistributedTensorConfigTraits {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::NONE;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ttnn::ReplicateTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ReplicateTensor;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ttnn::ShardTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ShardTensor;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ttnn::ShardTensor2D> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ShardTensor2D;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ttnn::AllGatherTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::AllGatherTensor;
};
 
bool VerifyDistributedTensorConfig(::flatbuffers::Verifier &verifier, const void *obj, DistributedTensorConfig type);
bool VerifyDistributedTensorConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<DistributedTensorConfig> *types);
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) CoreCoord FLATBUFFERS_FINAL_CLASS {
 private:
  uint64_t x_;
  uint64_t y_;
 
 public:
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.CoreCoord";
  }
  CoreCoord()
      : x_(0),
        y_(0) {
  }
  CoreCoord(uint64_t _x, uint64_t _y)
      : x_(::flatbuffers::EndianScalar(_x)),
        y_(::flatbuffers::EndianScalar(_y)) {
  }
  uint64_t x() const {
    return ::flatbuffers::EndianScalar(x_);
  }
  uint64_t y() const {
    return ::flatbuffers::EndianScalar(y_);
  }
};
FLATBUFFERS_STRUCT_END(CoreCoord, 16);
 
struct CoreCoord::Traits {
  using type = CoreCoord;
};
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) CoreRange FLATBUFFERS_FINAL_CLASS {
 private:
  tt::target::ttnn::CoreCoord start_coord_;
  tt::target::ttnn::CoreCoord end_coord_;
 
 public:
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.CoreRange";
  }
  CoreRange()
      : start_coord_(),
        end_coord_() {
  }
  CoreRange(const tt::target::ttnn::CoreCoord &_start_coord, const tt::target::ttnn::CoreCoord &_end_coord)
      : start_coord_(_start_coord),
        end_coord_(_end_coord) {
  }
  const tt::target::ttnn::CoreCoord &start_coord() const {
    return start_coord_;
  }
  const tt::target::ttnn::CoreCoord &end_coord() const {
    return end_coord_;
  }
};
FLATBUFFERS_STRUCT_END(CoreRange, 32);
 
struct CoreRange::Traits {
  using type = CoreRange;
};
 
struct CoreRangeSet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CoreRangeSetBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.CoreRangeSet";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CORE_RANGES = 4
  };
  const ::flatbuffers::Vector<const tt::target::ttnn::CoreRange *> *core_ranges() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::ttnn::CoreRange *> *>(VT_CORE_RANGES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CORE_RANGES) &&
           verifier.VerifyVector(core_ranges()) &&
           verifier.EndTable();
  }
};
 
struct CoreRangeSetBuilder {
  typedef CoreRangeSet Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_core_ranges(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ttnn::CoreRange *>> core_ranges) {
    fbb_.AddOffset(CoreRangeSet::VT_CORE_RANGES, core_ranges);
  }
  explicit CoreRangeSetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CoreRangeSet> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CoreRangeSet>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CoreRangeSet> CreateCoreRangeSet(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ttnn::CoreRange *>> core_ranges = 0) {
  CoreRangeSetBuilder builder_(_fbb);
  builder_.add_core_ranges(core_ranges);
  return builder_.Finish();
}
 
struct CoreRangeSet::Traits {
  using type = CoreRangeSet;
  static auto constexpr Create = CreateCoreRangeSet;
};
 
inline ::flatbuffers::Offset<CoreRangeSet> CreateCoreRangeSetDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<tt::target::ttnn::CoreRange> *core_ranges = nullptr) {
  auto core_ranges__ = core_ranges ? _fbb.CreateVectorOfStructs<tt::target::ttnn::CoreRange>(*core_ranges) : 0;
  return tt::target::ttnn::CreateCoreRangeSet(
      _fbb,
      core_ranges__);
}
 
struct ReplicateTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReplicateTensorBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ReplicateTensor";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REPLICATION_FACTOR = 4
  };
  uint32_t replication_factor() const {
    return GetField<uint32_t>(VT_REPLICATION_FACTOR, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_REPLICATION_FACTOR, 4) &&
           verifier.EndTable();
  }
};
 
struct ReplicateTensorBuilder {
  typedef ReplicateTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_replication_factor(uint32_t replication_factor) {
    fbb_.AddElement<uint32_t>(ReplicateTensor::VT_REPLICATION_FACTOR, replication_factor, 0);
  }
  explicit ReplicateTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReplicateTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReplicateTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReplicateTensor> CreateReplicateTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t replication_factor = 0) {
  ReplicateTensorBuilder builder_(_fbb);
  builder_.add_replication_factor(replication_factor);
  return builder_.Finish();
}
 
struct ReplicateTensor::Traits {
  using type = ReplicateTensor;
  static auto constexpr Create = CreateReplicateTensor;
};
 
struct ShardTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardTensorBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ShardTensor";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_DIM = 4
  };
  uint32_t shard_dim() const {
    return GetField<uint32_t>(VT_SHARD_DIM, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SHARD_DIM, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardTensorBuilder {
  typedef ShardTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_dim(uint32_t shard_dim) {
    fbb_.AddElement<uint32_t>(ShardTensor::VT_SHARD_DIM, shard_dim, 0);
  }
  explicit ShardTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardTensor> CreateShardTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t shard_dim = 0) {
  ShardTensorBuilder builder_(_fbb);
  builder_.add_shard_dim(shard_dim);
  return builder_.Finish();
}
 
struct ShardTensor::Traits {
  using type = ShardTensor;
  static auto constexpr Create = CreateShardTensor;
};
 
struct ShardTensor2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardTensor2DBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ShardTensor2D";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_MESH = 4
  };
  const tt::target::Dim2d *shard_mesh() const {
    return GetStruct<const tt::target::Dim2d *>(VT_SHARD_MESH);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_SHARD_MESH, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardTensor2DBuilder {
  typedef ShardTensor2D Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_mesh(const tt::target::Dim2d *shard_mesh) {
    fbb_.AddStruct(ShardTensor2D::VT_SHARD_MESH, shard_mesh);
  }
  explicit ShardTensor2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardTensor2D> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardTensor2D>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardTensor2D> CreateShardTensor2D(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Dim2d *shard_mesh = nullptr) {
  ShardTensor2DBuilder builder_(_fbb);
  builder_.add_shard_mesh(shard_mesh);
  return builder_.Finish();
}
 
struct ShardTensor2D::Traits {
  using type = ShardTensor2D;
  static auto constexpr Create = CreateShardTensor2D;
};
 
struct AllGatherTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AllGatherTensorBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.AllGatherTensor";
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};
 
struct AllGatherTensorBuilder {
  typedef AllGatherTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit AllGatherTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AllGatherTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AllGatherTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<AllGatherTensor> CreateAllGatherTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AllGatherTensorBuilder builder_(_fbb);
  return builder_.Finish();
}
 
struct AllGatherTensor::Traits {
  using type = AllGatherTensor;
  static auto constexpr Create = CreateAllGatherTensor;
};
 
struct DistributionStrategy FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DistributionStrategyBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.DistributionStrategy";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STRATEGY_TYPE = 4,
    VT_STRATEGY = 6
  };
  tt::target::ttnn::DistributedTensorConfig strategy_type() const {
    return static_cast<tt::target::ttnn::DistributedTensorConfig>(GetField<uint8_t>(VT_STRATEGY_TYPE, 0));
  }
  const void *strategy() const {
    return GetPointer<const void *>(VT_STRATEGY);
  }
  template<typename T> const T *strategy_as() const;
  const tt::target::ttnn::ReplicateTensor *strategy_as_ReplicateTensor() const {
    return strategy_type() == tt::target::ttnn::DistributedTensorConfig::ReplicateTensor ? static_cast<const tt::target::ttnn::ReplicateTensor *>(strategy()) : nullptr;
  }
  const tt::target::ttnn::ShardTensor *strategy_as_ShardTensor() const {
    return strategy_type() == tt::target::ttnn::DistributedTensorConfig::ShardTensor ? static_cast<const tt::target::ttnn::ShardTensor *>(strategy()) : nullptr;
  }
  const tt::target::ttnn::ShardTensor2D *strategy_as_ShardTensor2D() const {
    return strategy_type() == tt::target::ttnn::DistributedTensorConfig::ShardTensor2D ? static_cast<const tt::target::ttnn::ShardTensor2D *>(strategy()) : nullptr;
  }
  const tt::target::ttnn::AllGatherTensor *strategy_as_AllGatherTensor() const {
    return strategy_type() == tt::target::ttnn::DistributedTensorConfig::AllGatherTensor ? static_cast<const tt::target::ttnn::AllGatherTensor *>(strategy()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_STRATEGY_TYPE, 1) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           VerifyDistributedTensorConfig(verifier, strategy(), strategy_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::ReplicateTensor *DistributionStrategy::strategy_as<tt::target::ttnn::ReplicateTensor>() const {
  return strategy_as_ReplicateTensor();
}
 
template<> inline const tt::target::ttnn::ShardTensor *DistributionStrategy::strategy_as<tt::target::ttnn::ShardTensor>() const {
  return strategy_as_ShardTensor();
}
 
template<> inline const tt::target::ttnn::ShardTensor2D *DistributionStrategy::strategy_as<tt::target::ttnn::ShardTensor2D>() const {
  return strategy_as_ShardTensor2D();
}
 
template<> inline const tt::target::ttnn::AllGatherTensor *DistributionStrategy::strategy_as<tt::target::ttnn::AllGatherTensor>() const {
  return strategy_as_AllGatherTensor();
}
 
struct DistributionStrategyBuilder {
  typedef DistributionStrategy Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_strategy_type(tt::target::ttnn::DistributedTensorConfig strategy_type) {
    fbb_.AddElement<uint8_t>(DistributionStrategy::VT_STRATEGY_TYPE, static_cast<uint8_t>(strategy_type), 0);
  }
  void add_strategy(::flatbuffers::Offset<void> strategy) {
    fbb_.AddOffset(DistributionStrategy::VT_STRATEGY, strategy);
  }
  explicit DistributionStrategyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DistributionStrategy> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DistributionStrategy>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DistributionStrategy> CreateDistributionStrategy(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::DistributedTensorConfig strategy_type = tt::target::ttnn::DistributedTensorConfig::NONE,
    ::flatbuffers::Offset<void> strategy = 0) {
  DistributionStrategyBuilder builder_(_fbb);
  builder_.add_strategy(strategy);
  builder_.add_strategy_type(strategy_type);
  return builder_.Finish();
}
 
struct DistributionStrategy::Traits {
  using type = DistributionStrategy;
  static auto constexpr Create = CreateDistributionStrategy;
};
 
struct ShardSpec FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardSpecBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ShardSpec";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CORE_RANGE_SET = 4,
    VT_SHAPE = 6,
    VT_ORIENTATION = 8,
    VT_MODE = 10,
    VT_PHYSICAL_SHARD_SHAPE = 12
  };
  const tt::target::ttnn::CoreRangeSet *core_range_set() const {
    return GetPointer<const tt::target::ttnn::CoreRangeSet *>(VT_CORE_RANGE_SET);
  }
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  tt::target::ttnn::ShardOrientation orientation() const {
    return static_cast<tt::target::ttnn::ShardOrientation>(GetField<uint32_t>(VT_ORIENTATION, 0));
  }
  tt::target::ttnn::ShardMode mode() const {
    return static_cast<tt::target::ttnn::ShardMode>(GetField<uint32_t>(VT_MODE, 0));
  }
  const ::flatbuffers::Vector<int32_t> *physical_shard_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PHYSICAL_SHARD_SHAPE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CORE_RANGE_SET) &&
           verifier.VerifyTable(core_range_set()) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<uint32_t>(verifier, VT_ORIENTATION, 4) &&
           VerifyField<uint32_t>(verifier, VT_MODE, 4) &&
           VerifyOffset(verifier, VT_PHYSICAL_SHARD_SHAPE) &&
           verifier.VerifyVector(physical_shard_shape()) &&
           verifier.EndTable();
  }
};
 
struct ShardSpecBuilder {
  typedef ShardSpec Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_core_range_set(::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_range_set) {
    fbb_.AddOffset(ShardSpec::VT_CORE_RANGE_SET, core_range_set);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(ShardSpec::VT_SHAPE, shape);
  }
  void add_orientation(tt::target::ttnn::ShardOrientation orientation) {
    fbb_.AddElement<uint32_t>(ShardSpec::VT_ORIENTATION, static_cast<uint32_t>(orientation), 0);
  }
  void add_mode(tt::target::ttnn::ShardMode mode) {
    fbb_.AddElement<uint32_t>(ShardSpec::VT_MODE, static_cast<uint32_t>(mode), 0);
  }
  void add_physical_shard_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> physical_shard_shape) {
    fbb_.AddOffset(ShardSpec::VT_PHYSICAL_SHARD_SHAPE, physical_shard_shape);
  }
  explicit ShardSpecBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardSpec> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardSpec>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardSpec> CreateShardSpec(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_range_set = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    tt::target::ttnn::ShardOrientation orientation = tt::target::ttnn::ShardOrientation::RowMajor,
    tt::target::ttnn::ShardMode mode = tt::target::ttnn::ShardMode::Physical,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> physical_shard_shape = 0) {
  ShardSpecBuilder builder_(_fbb);
  builder_.add_physical_shard_shape(physical_shard_shape);
  builder_.add_mode(mode);
  builder_.add_orientation(orientation);
  builder_.add_shape(shape);
  builder_.add_core_range_set(core_range_set);
  return builder_.Finish();
}
 
struct ShardSpec::Traits {
  using type = ShardSpec;
  static auto constexpr Create = CreateShardSpec;
};
 
inline ::flatbuffers::Offset<ShardSpec> CreateShardSpecDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_range_set = 0,
    const std::vector<int32_t> *shape = nullptr,
    tt::target::ttnn::ShardOrientation orientation = tt::target::ttnn::ShardOrientation::RowMajor,
    tt::target::ttnn::ShardMode mode = tt::target::ttnn::ShardMode::Physical,
    const std::vector<int32_t> *physical_shard_shape = nullptr) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto physical_shard_shape__ = physical_shard_shape ? _fbb.CreateVector<int32_t>(*physical_shard_shape) : 0;
  return tt::target::ttnn::CreateShardSpec(
      _fbb,
      core_range_set,
      shape__,
      orientation,
      mode,
      physical_shard_shape__);
}
 
struct MemoryConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MemoryConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TENSOR_MEMORY_LAYOUT = 4,
    VT_BUFFER_TYPE = 6,
    VT_SHARD_SPEC = 8
  };
  tt::target::ttnn::TensorMemoryLayout tensor_memory_layout() const {
    return static_cast<tt::target::ttnn::TensorMemoryLayout>(GetField<uint16_t>(VT_TENSOR_MEMORY_LAYOUT, 0));
  }
  tt::target::BufferType buffer_type() const {
    return static_cast<tt::target::BufferType>(GetField<uint16_t>(VT_BUFFER_TYPE, 0));
  }
  const tt::target::ttnn::ShardSpec *shard_spec() const {
    return GetPointer<const tt::target::ttnn::ShardSpec *>(VT_SHARD_SPEC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_TENSOR_MEMORY_LAYOUT, 2) &&
           VerifyField<uint16_t>(verifier, VT_BUFFER_TYPE, 2) &&
           VerifyOffset(verifier, VT_SHARD_SPEC) &&
           verifier.VerifyTable(shard_spec()) &&
           verifier.EndTable();
  }
};
 
struct MemoryConfigBuilder {
  typedef MemoryConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_tensor_memory_layout(tt::target::ttnn::TensorMemoryLayout tensor_memory_layout) {
    fbb_.AddElement<uint16_t>(MemoryConfig::VT_TENSOR_MEMORY_LAYOUT, static_cast<uint16_t>(tensor_memory_layout), 0);
  }
  void add_buffer_type(tt::target::BufferType buffer_type) {
    fbb_.AddElement<uint16_t>(MemoryConfig::VT_BUFFER_TYPE, static_cast<uint16_t>(buffer_type), 0);
  }
  void add_shard_spec(::flatbuffers::Offset<tt::target::ttnn::ShardSpec> shard_spec) {
    fbb_.AddOffset(MemoryConfig::VT_SHARD_SPEC, shard_spec);
  }
  explicit MemoryConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryConfig> CreateMemoryConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::TensorMemoryLayout tensor_memory_layout = tt::target::ttnn::TensorMemoryLayout::Interleaved,
    tt::target::BufferType buffer_type = tt::target::BufferType::DRAM,
    ::flatbuffers::Offset<tt::target::ttnn::ShardSpec> shard_spec = 0) {
  MemoryConfigBuilder builder_(_fbb);
  builder_.add_shard_spec(shard_spec);
  builder_.add_buffer_type(buffer_type);
  builder_.add_tensor_memory_layout(tensor_memory_layout);
  return builder_.Finish();
}
 
struct MemoryConfig::Traits {
  using type = MemoryConfig;
  static auto constexpr Create = CreateMemoryConfig;
};
 
struct MemoryDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryDescBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MemoryDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STORAGE_TYPE = 4,
    VT_TILE_SHAPE = 6,
    VT_DATA_TYPE = 8,
    VT_MEMORY_CONFIG = 10,
    VT_SIZE = 12
  };
  tt::target::ttnn::StorageType storage_type() const {
    return static_cast<tt::target::ttnn::StorageType>(GetField<uint16_t>(VT_STORAGE_TYPE, 0));
  }
  const tt::target::Dim2d *tile_shape() const {
    return GetStruct<const tt::target::Dim2d *>(VT_TILE_SHAPE);
  }
  tt::target::DataType data_type() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DATA_TYPE, 0));
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_STORAGE_TYPE, 2) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_TILE_SHAPE, 4) &&
           VerifyField<uint16_t>(verifier, VT_DATA_TYPE, 2) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           verifier.EndTable();
  }
};
 
struct MemoryDescBuilder {
  typedef MemoryDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_storage_type(tt::target::ttnn::StorageType storage_type) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_STORAGE_TYPE, static_cast<uint16_t>(storage_type), 0);
  }
  void add_tile_shape(const tt::target::Dim2d *tile_shape) {
    fbb_.AddStruct(MemoryDesc::VT_TILE_SHAPE, tile_shape);
  }
  void add_data_type(tt::target::DataType data_type) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_DATA_TYPE, static_cast<uint16_t>(data_type), 0);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(MemoryDesc::VT_MEMORY_CONFIG, memory_config);
  }
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(MemoryDesc::VT_SIZE, size, 0);
  }
  explicit MemoryDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryDesc> CreateMemoryDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::StorageType storage_type = tt::target::ttnn::StorageType::Host,
    const tt::target::Dim2d *tile_shape = nullptr,
    tt::target::DataType data_type = tt::target::DataType::Float32,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    uint64_t size = 0) {
  MemoryDescBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_memory_config(memory_config);
  builder_.add_tile_shape(tile_shape);
  builder_.add_data_type(data_type);
  builder_.add_storage_type(storage_type);
  return builder_.Finish();
}
 
struct MemoryDesc::Traits {
  using type = MemoryDesc;
  static auto constexpr Create = CreateMemoryDesc;
};
 
struct LayoutDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LayoutDescBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.LayoutDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OOB_VAL = 4,
    VT_MEMORY_DESC = 6,
    VT_STRATEGY = 8
  };
  tt::target::OOBVal oob_val() const {
    return static_cast<tt::target::OOBVal>(GetField<uint16_t>(VT_OOB_VAL, 0));
  }
  const tt::target::ttnn::MemoryDesc *memory_desc() const {
    return GetPointer<const tt::target::ttnn::MemoryDesc *>(VT_MEMORY_DESC);
  }
  const tt::target::ttnn::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::ttnn::DistributionStrategy *>(VT_STRATEGY);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_OOB_VAL, 2) &&
           VerifyOffset(verifier, VT_MEMORY_DESC) &&
           verifier.VerifyTable(memory_desc()) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           verifier.VerifyTable(strategy()) &&
           verifier.EndTable();
  }
};
 
struct LayoutDescBuilder {
  typedef LayoutDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_oob_val(tt::target::OOBVal oob_val) {
    fbb_.AddElement<uint16_t>(LayoutDesc::VT_OOB_VAL, static_cast<uint16_t>(oob_val), 0);
  }
  void add_memory_desc(::flatbuffers::Offset<tt::target::ttnn::MemoryDesc> memory_desc) {
    fbb_.AddOffset(LayoutDesc::VT_MEMORY_DESC, memory_desc);
  }
  void add_strategy(::flatbuffers::Offset<tt::target::ttnn::DistributionStrategy> strategy) {
    fbb_.AddOffset(LayoutDesc::VT_STRATEGY, strategy);
  }
  explicit LayoutDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LayoutDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LayoutDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LayoutDesc> CreateLayoutDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::OOBVal oob_val = tt::target::OOBVal::Undef,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryDesc> memory_desc = 0,
    ::flatbuffers::Offset<tt::target::ttnn::DistributionStrategy> strategy = 0) {
  LayoutDescBuilder builder_(_fbb);
  builder_.add_strategy(strategy);
  builder_.add_memory_desc(memory_desc);
  builder_.add_oob_val(oob_val);
  return builder_.Finish();
}
 
struct LayoutDesc::Traits {
  using type = LayoutDesc;
  static auto constexpr Create = CreateLayoutDesc;
};
 
struct TensorDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorDescBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.TensorDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_MESH_SHAPE = 6,
    VT_LAYOUT = 8
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const ::flatbuffers::Vector<int32_t> *mesh_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_MESH_SHAPE);
  }
  const tt::target::ttnn::LayoutDesc *layout() const {
    return GetPointer<const tt::target::ttnn::LayoutDesc *>(VT_LAYOUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_MESH_SHAPE) &&
           verifier.VerifyVector(mesh_shape()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyTable(layout()) &&
           verifier.EndTable();
  }
};
 
struct TensorDescBuilder {
  typedef TensorDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(TensorDesc::VT_SHAPE, shape);
  }
  void add_mesh_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> mesh_shape) {
    fbb_.AddOffset(TensorDesc::VT_MESH_SHAPE, mesh_shape);
  }
  void add_layout(::flatbuffers::Offset<tt::target::ttnn::LayoutDesc> layout) {
    fbb_.AddOffset(TensorDesc::VT_LAYOUT, layout);
  }
  explicit TensorDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> mesh_shape = 0,
    ::flatbuffers::Offset<tt::target::ttnn::LayoutDesc> layout = 0) {
  TensorDescBuilder builder_(_fbb);
  builder_.add_layout(layout);
  builder_.add_mesh_shape(mesh_shape);
  builder_.add_shape(shape);
  return builder_.Finish();
}
 
struct TensorDesc::Traits {
  using type = TensorDesc;
  static auto constexpr Create = CreateTensorDesc;
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    const std::vector<int32_t> *mesh_shape = nullptr,
    ::flatbuffers::Offset<tt::target::ttnn::LayoutDesc> layout = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto mesh_shape__ = mesh_shape ? _fbb.CreateVector<int32_t>(*mesh_shape) : 0;
  return tt::target::ttnn::CreateTensorDesc(
      _fbb,
      shape__,
      mesh_shape__,
      layout);
}
 
struct TensorRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorRefBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.TensorRef";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4,
    VT_SIZE = 6,
    VT_DESC = 8
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  const tt::target::ttnn::TensorDesc *desc() const {
    return GetPointer<const tt::target::ttnn::TensorDesc *>(VT_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_GLOBAL_ID, 4) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           VerifyOffset(verifier, VT_DESC) &&
           verifier.VerifyTable(desc()) &&
           verifier.EndTable();
  }
};
 
struct TensorRefBuilder {
  typedef TensorRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(TensorRef::VT_GLOBAL_ID, global_id, 0);
  }
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(TensorRef::VT_SIZE, size, 0);
  }
  void add_desc(::flatbuffers::Offset<tt::target::ttnn::TensorDesc> desc) {
    fbb_.AddOffset(TensorRef::VT_DESC, desc);
  }
  explicit TensorRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorRef> CreateTensorRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t global_id = 0,
    uint64_t size = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorDesc> desc = 0) {
  TensorRefBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_desc(desc);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct TensorRef::Traits {
  using type = TensorRef;
  static auto constexpr Create = CreateTensorRef;
};
 
inline bool VerifyDistributedTensorConfig(::flatbuffers::Verifier &verifier, const void *obj, DistributedTensorConfig type) {
  switch (type) {
    case DistributedTensorConfig::NONE: {
      return true;
    }
    case DistributedTensorConfig::ReplicateTensor: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ReplicateTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::ShardTensor: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ShardTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::ShardTensor2D: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ShardTensor2D *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::AllGatherTensor: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::AllGatherTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyDistributedTensorConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<DistributedTensorConfig> *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 (!VerifyDistributedTensorConfig(
        verifier,  values->Get(i), types->GetEnum<DistributedTensorConfig>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_TYPES_TT_TARGET_TTNN_H_