creation_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_CREATION_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_CREATION_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"
#include "ttmlir/Target/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct ArangeOp;
struct ArangeOpBuilder;
 
struct ConstantOp;
struct ConstantOpBuilder;
 
struct ConstructTensorOp;
struct ConstructTensorOpBuilder;
 
struct EmptyOp;
struct EmptyOpBuilder;
 
struct FullOp;
struct FullOpBuilder;
 
struct NamedFullOp;
struct NamedFullOpBuilder;
 
enum class NamedFullOpType : uint32_t {
  Zeros = 0,
  Ones = 1,
  MIN = Zeros,
  MAX = Ones
};
 
inline const NamedFullOpType (&EnumValuesNamedFullOpType())[2] {
  static const NamedFullOpType values[] = {
    NamedFullOpType::Zeros,
    NamedFullOpType::Ones
  };
  return values;
}
 
inline const char * const *EnumNamesNamedFullOpType() {
  static const char * const names[3] = {
    "Zeros",
    "Ones",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameNamedFullOpType(NamedFullOpType e) {
  if (::flatbuffers::IsOutRange(e, NamedFullOpType::Zeros, NamedFullOpType::Ones)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesNamedFullOpType()[index];
}
 
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::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::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::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ArangeOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::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::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::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 ConstantOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstantOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OUT = 4,
    VT_DATA = 6
  };
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};
 
struct ConstantOpBuilder {
  typedef ConstantOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ConstantOp::VT_OUT, out);
  }
  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ConstantOp::VT_DATA, data);
  }
  explicit ConstantOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstantOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstantOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstantOp> CreateConstantOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
  ConstantOpBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_out(out);
  return builder_.Finish();
}
 
struct ConstantOp::Traits {
  using type = ConstantOp;
  static auto constexpr Create = CreateConstantOp;
};
 
inline ::flatbuffers::Offset<ConstantOp> CreateConstantOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return tt::target::ttnn::CreateConstantOp(
      _fbb,
      out,
      data__);
}
 
struct ConstructTensorOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConstructTensorOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_DTYPE = 6,
    VT_LAYOUT = 8,
    VT_OUT = 10
  };
  const ::flatbuffers::Vector<int64_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHAPE);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  tt::target::TensorLayout layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_LAYOUT, 0));
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::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_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ConstructTensorOpBuilder {
  typedef ConstructTensorOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(ConstructTensorOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ConstructTensorOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(ConstructTensorOp::VT_LAYOUT, static_cast<uint16_t>(layout), 0);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ConstructTensorOp::VT_OUT, out);
  }
  explicit ConstructTensorOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConstructTensorOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConstructTensorOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConstructTensorOp> CreateConstructTensorOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ConstructTensorOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_shape(shape);
  builder_.add_layout(layout);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct ConstructTensorOp::Traits {
  using type = ConstructTensorOp;
  static auto constexpr Create = CreateConstructTensorOp;
};
 
inline ::flatbuffers::Offset<ConstructTensorOp> CreateConstructTensorOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int64_t> *shape = nullptr,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateConstructTensorOp(
      _fbb,
      shape__,
      dtype,
      layout,
      out);
}
 
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::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::ttnn::DistributionStrategy *>(VT_STRATEGY);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::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::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(EmptyOp::VT_MEMCFG, memcfg);
  }
  void add_strategy(::flatbuffers::Offset<tt::target::ttnn::DistributionStrategy> strategy) {
    fbb_.AddOffset(EmptyOp::VT_STRATEGY, strategy);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::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::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::DistributionStrategy> strategy = 0,
    ::flatbuffers::Offset<tt::target::ttnn::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::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::DistributionStrategy> strategy = 0,
    ::flatbuffers::Offset<tt::target::ttnn::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 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::ttnn::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::ttnn::DistributionStrategy *>(VT_STRATEGY);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::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::ttnn::DistributionStrategy> strategy) {
    fbb_.AddOffset(FullOp::VT_STRATEGY, strategy);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::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::ttnn::DistributionStrategy> strategy = 0,
    ::flatbuffers::Offset<tt::target::ttnn::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 NamedFullOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NamedFullOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_SHAPE = 6,
    VT_DTYPE = 8,
    VT_LAYOUT = 10,
    VT_DEVICE = 12,
    VT_MEMCFG = 14,
    VT_OUT = 16
  };
  tt::target::ttnn::NamedFullOpType type() const {
    return static_cast<tt::target::ttnn::NamedFullOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  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::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           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 NamedFullOpBuilder {
  typedef NamedFullOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::NamedFullOpType type) {
    fbb_.AddElement<uint32_t>(NamedFullOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shape) {
    fbb_.AddOffset(NamedFullOp::VT_SHAPE, shape);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(NamedFullOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(NamedFullOp::VT_LAYOUT, static_cast<uint16_t>(layout));
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(NamedFullOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(NamedFullOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(NamedFullOp::VT_OUT, out);
  }
  explicit NamedFullOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NamedFullOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NamedFullOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<NamedFullOp> CreateNamedFullOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::NamedFullOpType type = tt::target::ttnn::NamedFullOpType::Zeros,
    ::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::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  NamedFullOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_shape(shape);
  builder_.add_type(type);
  if(layout) { builder_.add_layout(*layout); }
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct NamedFullOp::Traits {
  using type = NamedFullOp;
  static auto constexpr Create = CreateNamedFullOp;
};
 
inline ::flatbuffers::Offset<NamedFullOp> CreateNamedFullOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::NamedFullOpType type = tt::target::ttnn::NamedFullOpType::Zeros,
    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::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int64_t>(*shape) : 0;
  return tt::target::ttnn::CreateNamedFullOp(
      _fbb,
      type,
      shape__,
      dtype,
      layout,
      device,
      memcfg,
      out);
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_CREATION_TT_TARGET_TTNN_H_