data_movement_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_DATAMOVEMENT_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_DATAMOVEMENT_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 ConcatOp;
struct ConcatOpBuilder;
 
struct PadOp;
struct PadOpBuilder;
 
struct PermuteOp;
struct PermuteOpBuilder;
 
struct RepeatInterleaveOp;
struct RepeatInterleaveOpBuilder;
 
struct RepeatOp;
struct RepeatOpBuilder;
 
struct ReshapeOp;
struct ReshapeOpBuilder;
 
struct SliceOp;
struct SliceOpBuilder;
 
struct TransposeOp;
struct TransposeOpBuilder;
 
struct ConcatOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConcatOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ConcatOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUTS = 4,
    VT_OUT = 6,
    VT_DIM = 8,
    VT_MEMORY_CONFIG = 10
  };
  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 tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  int32_t dim() const {
    return GetField<int32_t>(VT_DIM, 0);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIM, 4) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           verifier.EndTable();
  }
};
 
struct ConcatOpBuilder {
  typedef ConcatOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs) {
    fbb_.AddOffset(ConcatOp::VT_INPUTS, inputs);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ConcatOp::VT_OUT, out);
  }
  void add_dim(int32_t dim) {
    fbb_.AddElement<int32_t>(ConcatOp::VT_DIM, dim, 0);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(ConcatOp::VT_MEMORY_CONFIG, memory_config);
  }
  explicit ConcatOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConcatOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConcatOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConcatOp> CreateConcatOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    int32_t dim = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0) {
  ConcatOpBuilder builder_(_fbb);
  builder_.add_memory_config(memory_config);
  builder_.add_dim(dim);
  builder_.add_out(out);
  builder_.add_inputs(inputs);
  return builder_.Finish();
}
 
struct ConcatOp::Traits {
  using type = ConcatOp;
  static auto constexpr Create = CreateConcatOp;
};
 
inline ::flatbuffers::Offset<ConcatOp> CreateConcatOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs = nullptr,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    int32_t dim = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0) {
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*inputs) : 0;
  return tt::target::ttnn::CreateConcatOp(
      _fbb,
      inputs__,
      out,
      dim,
      memory_config);
}
 
struct PadOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PadOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PadOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_PADDING = 8,
    VT_VALUE = 10,
    VT_USE_MULTICORE = 12,
    VT_MEMCFG = 14
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<uint32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_PADDING);
  }
  float value() const {
    return GetField<float>(VT_VALUE, 0.0f);
  }
  bool use_multicore() const {
    return GetField<uint8_t>(VT_USE_MULTICORE, 0) != 0;
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyField<float>(verifier, VT_VALUE, 4) &&
           VerifyField<uint8_t>(verifier, VT_USE_MULTICORE, 1) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           verifier.EndTable();
  }
};
 
struct PadOpBuilder {
  typedef PadOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(PadOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(PadOp::VT_OUT, out);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> padding) {
    fbb_.AddOffset(PadOp::VT_PADDING, padding);
  }
  void add_value(float value) {
    fbb_.AddElement<float>(PadOp::VT_VALUE, value, 0.0f);
  }
  void add_use_multicore(bool use_multicore) {
    fbb_.AddElement<uint8_t>(PadOp::VT_USE_MULTICORE, static_cast<uint8_t>(use_multicore), 0);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(PadOp::VT_MEMCFG, memcfg);
  }
  explicit PadOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PadOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PadOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PadOp> CreatePadOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> padding = 0,
    float value = 0.0f,
    bool use_multicore = false,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0) {
  PadOpBuilder builder_(_fbb);
  builder_.add_memcfg(memcfg);
  builder_.add_value(value);
  builder_.add_padding(padding);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_use_multicore(use_multicore);
  return builder_.Finish();
}
 
struct PadOp::Traits {
  using type = PadOp;
  static auto constexpr Create = CreatePadOp;
};
 
inline ::flatbuffers::Offset<PadOp> CreatePadOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<uint32_t> *padding = nullptr,
    float value = 0.0f,
    bool use_multicore = false,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0) {
  auto padding__ = padding ? _fbb.CreateVector<uint32_t>(*padding) : 0;
  return tt::target::ttnn::CreatePadOp(
      _fbb,
      in,
      out,
      padding__,
      value,
      use_multicore,
      memcfg);
}
 
struct PermuteOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PermuteOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PermuteOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_PERMUTATION = 6,
    VT_MEMORY_CONFIG = 8,
    VT_PAD_VALUE = 10,
    VT_OUT = 12
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const ::flatbuffers::Vector<int64_t> *permutation() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_PERMUTATION);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  float pad_value() const {
    return GetField<float>(VT_PAD_VALUE, 0.0f);
  }
  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_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_PERMUTATION) &&
           verifier.VerifyVector(permutation()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyField<float>(verifier, VT_PAD_VALUE, 4) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct PermuteOpBuilder {
  typedef PermuteOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(PermuteOp::VT_IN, in);
  }
  void add_permutation(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation) {
    fbb_.AddOffset(PermuteOp::VT_PERMUTATION, permutation);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(PermuteOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_pad_value(float pad_value) {
    fbb_.AddElement<float>(PermuteOp::VT_PAD_VALUE, pad_value, 0.0f);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(PermuteOp::VT_OUT, out);
  }
  explicit PermuteOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PermuteOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PermuteOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PermuteOp> CreatePermuteOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> permutation = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    float pad_value = 0.0f,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  PermuteOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_pad_value(pad_value);
  builder_.add_memory_config(memory_config);
  builder_.add_permutation(permutation);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct PermuteOp::Traits {
  using type = PermuteOp;
  static auto constexpr Create = CreatePermuteOp;
};
 
inline ::flatbuffers::Offset<PermuteOp> CreatePermuteOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    const std::vector<int64_t> *permutation = nullptr,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    float pad_value = 0.0f,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto permutation__ = permutation ? _fbb.CreateVector<int64_t>(*permutation) : 0;
  return tt::target::ttnn::CreatePermuteOp(
      _fbb,
      in,
      permutation__,
      memory_config,
      pad_value,
      out);
}
 
struct RepeatInterleaveOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RepeatInterleaveOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.RepeatInterleaveOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_OUT = 6,
    VT_REPEATS = 8,
    VT_DIM = 10,
    VT_MEMORY_CONFIG = 12
  };
  const tt::target::ttnn::TensorRef *input() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_INPUT);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  uint32_t repeats() const {
    return GetField<uint32_t>(VT_REPEATS, 0);
  }
  int32_t dim() const {
    return GetField<int32_t>(VT_DIM, 0);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint32_t>(verifier, VT_REPEATS, 4) &&
           VerifyField<int32_t>(verifier, VT_DIM, 4) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           verifier.EndTable();
  }
};
 
struct RepeatInterleaveOpBuilder {
  typedef RepeatInterleaveOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::ttnn::TensorRef> input) {
    fbb_.AddOffset(RepeatInterleaveOp::VT_INPUT, input);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(RepeatInterleaveOp::VT_OUT, out);
  }
  void add_repeats(uint32_t repeats) {
    fbb_.AddElement<uint32_t>(RepeatInterleaveOp::VT_REPEATS, repeats, 0);
  }
  void add_dim(int32_t dim) {
    fbb_.AddElement<int32_t>(RepeatInterleaveOp::VT_DIM, dim, 0);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(RepeatInterleaveOp::VT_MEMORY_CONFIG, memory_config);
  }
  explicit RepeatInterleaveOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RepeatInterleaveOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RepeatInterleaveOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<RepeatInterleaveOp> CreateRepeatInterleaveOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    uint32_t repeats = 0,
    int32_t dim = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0) {
  RepeatInterleaveOpBuilder builder_(_fbb);
  builder_.add_memory_config(memory_config);
  builder_.add_dim(dim);
  builder_.add_repeats(repeats);
  builder_.add_out(out);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct RepeatInterleaveOp::Traits {
  using type = RepeatInterleaveOp;
  static auto constexpr Create = CreateRepeatInterleaveOp;
};
 
struct RepeatOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RepeatOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.RepeatOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_REPEAT_DIMS = 8
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<int64_t> *repeat_dims() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_REPEAT_DIMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_REPEAT_DIMS) &&
           verifier.VerifyVector(repeat_dims()) &&
           verifier.EndTable();
  }
};
 
struct RepeatOpBuilder {
  typedef RepeatOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(RepeatOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(RepeatOp::VT_OUT, out);
  }
  void add_repeat_dims(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> repeat_dims) {
    fbb_.AddOffset(RepeatOp::VT_REPEAT_DIMS, repeat_dims);
  }
  explicit RepeatOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RepeatOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RepeatOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<RepeatOp> CreateRepeatOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> repeat_dims = 0) {
  RepeatOpBuilder builder_(_fbb);
  builder_.add_repeat_dims(repeat_dims);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct RepeatOp::Traits {
  using type = RepeatOp;
  static auto constexpr Create = CreateRepeatOp;
};
 
inline ::flatbuffers::Offset<RepeatOp> CreateRepeatOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<int64_t> *repeat_dims = nullptr) {
  auto repeat_dims__ = repeat_dims ? _fbb.CreateVector<int64_t>(*repeat_dims) : 0;
  return tt::target::ttnn::CreateRepeatOp(
      _fbb,
      in,
      out,
      repeat_dims__);
}
 
struct ReshapeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReshapeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ReshapeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_SHAPE = 8,
    VT_MEMORY_CONFIG = 10
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           verifier.EndTable();
  }
};
 
struct ReshapeOpBuilder {
  typedef ReshapeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ReshapeOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ReshapeOp::VT_OUT, out);
  }
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(ReshapeOp::VT_SHAPE, shape);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(ReshapeOp::VT_MEMORY_CONFIG, memory_config);
  }
  explicit ReshapeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReshapeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReshapeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReshapeOp> CreateReshapeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0) {
  ReshapeOpBuilder builder_(_fbb);
  builder_.add_memory_config(memory_config);
  builder_.add_shape(shape);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct ReshapeOp::Traits {
  using type = ReshapeOp;
  static auto constexpr Create = CreateReshapeOp;
};
 
inline ::flatbuffers::Offset<ReshapeOp> CreateReshapeOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<int32_t> *shape = nullptr,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tt::target::ttnn::CreateReshapeOp(
      _fbb,
      in,
      out,
      shape__,
      memory_config);
}
 
struct SliceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SliceOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.SliceOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_BEGINS = 8,
    VT_ENDS = 10,
    VT_STEP = 12
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const ::flatbuffers::Vector<int64_t> *begins() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_BEGINS);
  }
  const ::flatbuffers::Vector<int64_t> *ends() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ENDS);
  }
  const ::flatbuffers::Vector<int64_t> *step() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_STEP);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_BEGINS) &&
           verifier.VerifyVector(begins()) &&
           VerifyOffset(verifier, VT_ENDS) &&
           verifier.VerifyVector(ends()) &&
           VerifyOffset(verifier, VT_STEP) &&
           verifier.VerifyVector(step()) &&
           verifier.EndTable();
  }
};
 
struct SliceOpBuilder {
  typedef SliceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(SliceOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(SliceOp::VT_OUT, out);
  }
  void add_begins(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> begins) {
    fbb_.AddOffset(SliceOp::VT_BEGINS, begins);
  }
  void add_ends(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> ends) {
    fbb_.AddOffset(SliceOp::VT_ENDS, ends);
  }
  void add_step(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> step) {
    fbb_.AddOffset(SliceOp::VT_STEP, step);
  }
  explicit SliceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SliceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SliceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<SliceOp> CreateSliceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> begins = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> ends = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> step = 0) {
  SliceOpBuilder builder_(_fbb);
  builder_.add_step(step);
  builder_.add_ends(ends);
  builder_.add_begins(begins);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct SliceOp::Traits {
  using type = SliceOp;
  static auto constexpr Create = CreateSliceOp;
};
 
inline ::flatbuffers::Offset<SliceOp> CreateSliceOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<int64_t> *begins = nullptr,
    const std::vector<int64_t> *ends = nullptr,
    const std::vector<int64_t> *step = nullptr) {
  auto begins__ = begins ? _fbb.CreateVector<int64_t>(*begins) : 0;
  auto ends__ = ends ? _fbb.CreateVector<int64_t>(*ends) : 0;
  auto step__ = step ? _fbb.CreateVector<int64_t>(*step) : 0;
  return tt::target::ttnn::CreateSliceOp(
      _fbb,
      in,
      out,
      begins__,
      ends__,
      step__);
}
 
struct TransposeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TransposeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.TransposeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DIM0 = 8,
    VT_DIM1 = 10
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  int32_t dim0() const {
    return GetField<int32_t>(VT_DIM0, 0);
  }
  int32_t dim1() const {
    return GetField<int32_t>(VT_DIM1, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIM0, 4) &&
           VerifyField<int32_t>(verifier, VT_DIM1, 4) &&
           verifier.EndTable();
  }
};
 
struct TransposeOpBuilder {
  typedef TransposeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(TransposeOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(TransposeOp::VT_OUT, out);
  }
  void add_dim0(int32_t dim0) {
    fbb_.AddElement<int32_t>(TransposeOp::VT_DIM0, dim0, 0);
  }
  void add_dim1(int32_t dim1) {
    fbb_.AddElement<int32_t>(TransposeOp::VT_DIM1, dim1, 0);
  }
  explicit TransposeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TransposeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TransposeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TransposeOp> CreateTransposeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    int32_t dim0 = 0,
    int32_t dim1 = 0) {
  TransposeOpBuilder builder_(_fbb);
  builder_.add_dim1(dim1);
  builder_.add_dim0(dim0);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct TransposeOp::Traits {
  using type = TransposeOp;
  static auto constexpr Create = CreateTransposeOp;
};
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_DATAMOVEMENT_TT_TARGET_TTNN_H_