matmul_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_MATMUL_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_MATMUL_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/operations/eltwise_generated.h"
#include "ttmlir/Target/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct MatmulMultiCoreReuseProgramConfig;
struct MatmulMultiCoreReuseProgramConfigBuilder;
 
struct MatmulMultiCoreReuseMultiCastProgramConfig;
struct MatmulMultiCoreReuseMultiCastProgramConfigBuilder;
 
struct MatmulMultiCoreReuseMultiCast1DProgramConfig;
struct MatmulMultiCoreReuseMultiCast1DProgramConfigBuilder;
 
struct MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig;
struct MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfigBuilder;
 
struct MatmulOp;
struct MatmulOpBuilder;
 
struct LinearOp;
struct LinearOpBuilder;
 
enum class MatmulProgramConfig : uint8_t {
  NONE = 0,
  MatmulMultiCoreReuseProgramConfig = 1,
  MatmulMultiCoreReuseMultiCastProgramConfig = 2,
  MatmulMultiCoreReuseMultiCast1DProgramConfig = 3,
  MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig = 4,
  MIN = NONE,
  MAX = MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig
};
 
inline const MatmulProgramConfig (&EnumValuesMatmulProgramConfig())[5] {
  static const MatmulProgramConfig values[] = {
    MatmulProgramConfig::NONE,
    MatmulProgramConfig::MatmulMultiCoreReuseProgramConfig,
    MatmulProgramConfig::MatmulMultiCoreReuseMultiCastProgramConfig,
    MatmulProgramConfig::MatmulMultiCoreReuseMultiCast1DProgramConfig,
    MatmulProgramConfig::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig
  };
  return values;
}
 
inline const char * const *EnumNamesMatmulProgramConfig() {
  static const char * const names[6] = {
    "NONE",
    "MatmulMultiCoreReuseProgramConfig",
    "MatmulMultiCoreReuseMultiCastProgramConfig",
    "MatmulMultiCoreReuseMultiCast1DProgramConfig",
    "MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMatmulProgramConfig(MatmulProgramConfig e) {
  if (::flatbuffers::IsOutRange(e, MatmulProgramConfig::NONE, MatmulProgramConfig::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMatmulProgramConfig()[index];
}
 
template<typename T> struct MatmulProgramConfigTraits {
  static const MatmulProgramConfig enum_value = MatmulProgramConfig::NONE;
};
 
template<> struct MatmulProgramConfigTraits<tt::target::ttnn::MatmulMultiCoreReuseProgramConfig> {
  static const MatmulProgramConfig enum_value = MatmulProgramConfig::MatmulMultiCoreReuseProgramConfig;
};
 
template<> struct MatmulProgramConfigTraits<tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig> {
  static const MatmulProgramConfig enum_value = MatmulProgramConfig::MatmulMultiCoreReuseMultiCastProgramConfig;
};
 
template<> struct MatmulProgramConfigTraits<tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig> {
  static const MatmulProgramConfig enum_value = MatmulProgramConfig::MatmulMultiCoreReuseMultiCast1DProgramConfig;
};
 
template<> struct MatmulProgramConfigTraits<tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig> {
  static const MatmulProgramConfig enum_value = MatmulProgramConfig::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig;
};
 
bool VerifyMatmulProgramConfig(::flatbuffers::Verifier &verifier, const void *obj, MatmulProgramConfig type);
bool VerifyMatmulProgramConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<MatmulProgramConfig> *types);
 
struct MatmulMultiCoreReuseProgramConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulMultiCoreReuseProgramConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MatmulMultiCoreReuseProgramConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMPUTE_WITH_STORAGE_GRID_SIZE = 4,
    VT_IN0_BLOCK_W = 6,
    VT_OUT_SUBBLOCK_H = 8,
    VT_OUT_SUBBLOCK_W = 10,
    VT_PER_CORE_M = 12,
    VT_PER_CORE_N = 14
  };
  const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size() const {
    return GetStruct<const tt::target::ttnn::CoreCoord *>(VT_COMPUTE_WITH_STORAGE_GRID_SIZE);
  }
  uint64_t in0_block_w() const {
    return GetField<uint64_t>(VT_IN0_BLOCK_W, 0);
  }
  uint64_t out_subblock_h() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_H, 0);
  }
  uint64_t out_subblock_w() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_W, 0);
  }
  uint64_t per_core_m() const {
    return GetField<uint64_t>(VT_PER_CORE_M, 0);
  }
  uint64_t per_core_n() const {
    return GetField<uint64_t>(VT_PER_CORE_N, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::ttnn::CoreCoord>(verifier, VT_COMPUTE_WITH_STORAGE_GRID_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_IN0_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_H, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_M, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_N, 8) &&
           verifier.EndTable();
  }
};
 
struct MatmulMultiCoreReuseProgramConfigBuilder {
  typedef MatmulMultiCoreReuseProgramConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_compute_with_storage_grid_size(const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size) {
    fbb_.AddStruct(MatmulMultiCoreReuseProgramConfig::VT_COMPUTE_WITH_STORAGE_GRID_SIZE, compute_with_storage_grid_size);
  }
  void add_in0_block_w(uint64_t in0_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseProgramConfig::VT_IN0_BLOCK_W, in0_block_w, 0);
  }
  void add_out_subblock_h(uint64_t out_subblock_h) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseProgramConfig::VT_OUT_SUBBLOCK_H, out_subblock_h, 0);
  }
  void add_out_subblock_w(uint64_t out_subblock_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseProgramConfig::VT_OUT_SUBBLOCK_W, out_subblock_w, 0);
  }
  void add_per_core_m(uint64_t per_core_m) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseProgramConfig::VT_PER_CORE_M, per_core_m, 0);
  }
  void add_per_core_n(uint64_t per_core_n) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseProgramConfig::VT_PER_CORE_N, per_core_n, 0);
  }
  explicit MatmulMultiCoreReuseProgramConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulMultiCoreReuseProgramConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulMultiCoreReuseProgramConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulMultiCoreReuseProgramConfig> CreateMatmulMultiCoreReuseProgramConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size = nullptr,
    uint64_t in0_block_w = 0,
    uint64_t out_subblock_h = 0,
    uint64_t out_subblock_w = 0,
    uint64_t per_core_m = 0,
    uint64_t per_core_n = 0) {
  MatmulMultiCoreReuseProgramConfigBuilder builder_(_fbb);
  builder_.add_per_core_n(per_core_n);
  builder_.add_per_core_m(per_core_m);
  builder_.add_out_subblock_w(out_subblock_w);
  builder_.add_out_subblock_h(out_subblock_h);
  builder_.add_in0_block_w(in0_block_w);
  builder_.add_compute_with_storage_grid_size(compute_with_storage_grid_size);
  return builder_.Finish();
}
 
struct MatmulMultiCoreReuseProgramConfig::Traits {
  using type = MatmulMultiCoreReuseProgramConfig;
  static auto constexpr Create = CreateMatmulMultiCoreReuseProgramConfig;
};
 
struct MatmulMultiCoreReuseMultiCastProgramConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulMultiCoreReuseMultiCastProgramConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MatmulMultiCoreReuseMultiCastProgramConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMPUTE_WITH_STORAGE_GRID_SIZE = 4,
    VT_IN0_BLOCK_W = 6,
    VT_OUT_SUBBLOCK_H = 8,
    VT_OUT_SUBBLOCK_W = 10,
    VT_OUT_BLOCK_H = 12,
    VT_OUT_BLOCK_W = 14,
    VT_PER_CORE_M = 16,
    VT_PER_CORE_N = 18,
    VT_TRANSPOSE_MCAST = 20,
    VT_FUSED_ACTIVATION = 22,
    VT_FUSE_BATCH = 24
  };
  const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size() const {
    return GetStruct<const tt::target::ttnn::CoreCoord *>(VT_COMPUTE_WITH_STORAGE_GRID_SIZE);
  }
  uint64_t in0_block_w() const {
    return GetField<uint64_t>(VT_IN0_BLOCK_W, 0);
  }
  uint64_t out_subblock_h() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_H, 0);
  }
  uint64_t out_subblock_w() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_W, 0);
  }
  uint64_t out_block_h() const {
    return GetField<uint64_t>(VT_OUT_BLOCK_H, 0);
  }
  uint64_t out_block_w() const {
    return GetField<uint64_t>(VT_OUT_BLOCK_W, 0);
  }
  uint64_t per_core_m() const {
    return GetField<uint64_t>(VT_PER_CORE_M, 0);
  }
  uint64_t per_core_n() const {
    return GetField<uint64_t>(VT_PER_CORE_N, 0);
  }
  bool transpose_mcast() const {
    return GetField<uint8_t>(VT_TRANSPOSE_MCAST, 0) != 0;
  }
  const tt::target::ttnn::UnaryWithParam *fused_activation() const {
    return GetPointer<const tt::target::ttnn::UnaryWithParam *>(VT_FUSED_ACTIVATION);
  }
  bool fuse_batch() const {
    return GetField<uint8_t>(VT_FUSE_BATCH, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::ttnn::CoreCoord>(verifier, VT_COMPUTE_WITH_STORAGE_GRID_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_IN0_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_H, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_BLOCK_H, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_M, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_N, 8) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_MCAST, 1) &&
           VerifyOffset(verifier, VT_FUSED_ACTIVATION) &&
           verifier.VerifyTable(fused_activation()) &&
           VerifyField<uint8_t>(verifier, VT_FUSE_BATCH, 1) &&
           verifier.EndTable();
  }
};
 
struct MatmulMultiCoreReuseMultiCastProgramConfigBuilder {
  typedef MatmulMultiCoreReuseMultiCastProgramConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_compute_with_storage_grid_size(const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size) {
    fbb_.AddStruct(MatmulMultiCoreReuseMultiCastProgramConfig::VT_COMPUTE_WITH_STORAGE_GRID_SIZE, compute_with_storage_grid_size);
  }
  void add_in0_block_w(uint64_t in0_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_IN0_BLOCK_W, in0_block_w, 0);
  }
  void add_out_subblock_h(uint64_t out_subblock_h) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_OUT_SUBBLOCK_H, out_subblock_h, 0);
  }
  void add_out_subblock_w(uint64_t out_subblock_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_OUT_SUBBLOCK_W, out_subblock_w, 0);
  }
  void add_out_block_h(uint64_t out_block_h) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_OUT_BLOCK_H, out_block_h, 0);
  }
  void add_out_block_w(uint64_t out_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_OUT_BLOCK_W, out_block_w, 0);
  }
  void add_per_core_m(uint64_t per_core_m) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_PER_CORE_M, per_core_m, 0);
  }
  void add_per_core_n(uint64_t per_core_n) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_PER_CORE_N, per_core_n, 0);
  }
  void add_transpose_mcast(bool transpose_mcast) {
    fbb_.AddElement<uint8_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_TRANSPOSE_MCAST, static_cast<uint8_t>(transpose_mcast), 0);
  }
  void add_fused_activation(::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation) {
    fbb_.AddOffset(MatmulMultiCoreReuseMultiCastProgramConfig::VT_FUSED_ACTIVATION, fused_activation);
  }
  void add_fuse_batch(bool fuse_batch) {
    fbb_.AddElement<uint8_t>(MatmulMultiCoreReuseMultiCastProgramConfig::VT_FUSE_BATCH, static_cast<uint8_t>(fuse_batch), 0);
  }
  explicit MatmulMultiCoreReuseMultiCastProgramConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastProgramConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastProgramConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastProgramConfig> CreateMatmulMultiCoreReuseMultiCastProgramConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size = nullptr,
    uint64_t in0_block_w = 0,
    uint64_t out_subblock_h = 0,
    uint64_t out_subblock_w = 0,
    uint64_t out_block_h = 0,
    uint64_t out_block_w = 0,
    uint64_t per_core_m = 0,
    uint64_t per_core_n = 0,
    bool transpose_mcast = false,
    ::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation = 0,
    bool fuse_batch = false) {
  MatmulMultiCoreReuseMultiCastProgramConfigBuilder builder_(_fbb);
  builder_.add_per_core_n(per_core_n);
  builder_.add_per_core_m(per_core_m);
  builder_.add_out_block_w(out_block_w);
  builder_.add_out_block_h(out_block_h);
  builder_.add_out_subblock_w(out_subblock_w);
  builder_.add_out_subblock_h(out_subblock_h);
  builder_.add_in0_block_w(in0_block_w);
  builder_.add_fused_activation(fused_activation);
  builder_.add_compute_with_storage_grid_size(compute_with_storage_grid_size);
  builder_.add_fuse_batch(fuse_batch);
  builder_.add_transpose_mcast(transpose_mcast);
  return builder_.Finish();
}
 
struct MatmulMultiCoreReuseMultiCastProgramConfig::Traits {
  using type = MatmulMultiCoreReuseMultiCastProgramConfig;
  static auto constexpr Create = CreateMatmulMultiCoreReuseMultiCastProgramConfig;
};
 
struct MatmulMultiCoreReuseMultiCast1DProgramConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulMultiCoreReuseMultiCast1DProgramConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MatmulMultiCoreReuseMultiCast1DProgramConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMPUTE_WITH_STORAGE_GRID_SIZE = 4,
    VT_IN0_BLOCK_W = 6,
    VT_OUT_SUBBLOCK_H = 8,
    VT_OUT_SUBBLOCK_W = 10,
    VT_OUT_BLOCK_H = 12,
    VT_OUT_BLOCK_W = 14,
    VT_PER_CORE_M = 16,
    VT_PER_CORE_N = 18,
    VT_FUSE_BATCH = 20,
    VT_FUSED_ACTIVATION = 22,
    VT_MCAST_IN0 = 24,
    VT_GATHER_IN0 = 26,
    VT_HOP_CORES = 28,
    VT_NUM_GLOBAL_CB_RECEIVERS = 30
  };
  const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size() const {
    return GetStruct<const tt::target::ttnn::CoreCoord *>(VT_COMPUTE_WITH_STORAGE_GRID_SIZE);
  }
  uint64_t in0_block_w() const {
    return GetField<uint64_t>(VT_IN0_BLOCK_W, 0);
  }
  uint64_t out_subblock_h() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_H, 0);
  }
  uint64_t out_subblock_w() const {
    return GetField<uint64_t>(VT_OUT_SUBBLOCK_W, 0);
  }
  uint64_t out_block_h() const {
    return GetField<uint64_t>(VT_OUT_BLOCK_H, 0);
  }
  uint64_t out_block_w() const {
    return GetField<uint64_t>(VT_OUT_BLOCK_W, 0);
  }
  uint64_t per_core_m() const {
    return GetField<uint64_t>(VT_PER_CORE_M, 0);
  }
  uint64_t per_core_n() const {
    return GetField<uint64_t>(VT_PER_CORE_N, 0);
  }
  bool fuse_batch() const {
    return GetField<uint8_t>(VT_FUSE_BATCH, 0) != 0;
  }
  const tt::target::ttnn::UnaryWithParam *fused_activation() const {
    return GetPointer<const tt::target::ttnn::UnaryWithParam *>(VT_FUSED_ACTIVATION);
  }
  bool mcast_in0() const {
    return GetField<uint8_t>(VT_MCAST_IN0, 0) != 0;
  }
  bool gather_in0() const {
    return GetField<uint8_t>(VT_GATHER_IN0, 0) != 0;
  }
  const tt::target::ttnn::CoreRangeSet *hop_cores() const {
    return GetPointer<const tt::target::ttnn::CoreRangeSet *>(VT_HOP_CORES);
  }
  uint64_t num_global_cb_receivers() const {
    return GetField<uint64_t>(VT_NUM_GLOBAL_CB_RECEIVERS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::ttnn::CoreCoord>(verifier, VT_COMPUTE_WITH_STORAGE_GRID_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_IN0_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_H, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_SUBBLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_BLOCK_H, 8) &&
           VerifyField<uint64_t>(verifier, VT_OUT_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_M, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_N, 8) &&
           VerifyField<uint8_t>(verifier, VT_FUSE_BATCH, 1) &&
           VerifyOffset(verifier, VT_FUSED_ACTIVATION) &&
           verifier.VerifyTable(fused_activation()) &&
           VerifyField<uint8_t>(verifier, VT_MCAST_IN0, 1) &&
           VerifyField<uint8_t>(verifier, VT_GATHER_IN0, 1) &&
           VerifyOffset(verifier, VT_HOP_CORES) &&
           verifier.VerifyTable(hop_cores()) &&
           VerifyField<uint64_t>(verifier, VT_NUM_GLOBAL_CB_RECEIVERS, 8) &&
           verifier.EndTable();
  }
};
 
struct MatmulMultiCoreReuseMultiCast1DProgramConfigBuilder {
  typedef MatmulMultiCoreReuseMultiCast1DProgramConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_compute_with_storage_grid_size(const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size) {
    fbb_.AddStruct(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_COMPUTE_WITH_STORAGE_GRID_SIZE, compute_with_storage_grid_size);
  }
  void add_in0_block_w(uint64_t in0_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_IN0_BLOCK_W, in0_block_w, 0);
  }
  void add_out_subblock_h(uint64_t out_subblock_h) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_OUT_SUBBLOCK_H, out_subblock_h, 0);
  }
  void add_out_subblock_w(uint64_t out_subblock_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_OUT_SUBBLOCK_W, out_subblock_w, 0);
  }
  void add_out_block_h(uint64_t out_block_h) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_OUT_BLOCK_H, out_block_h, 0);
  }
  void add_out_block_w(uint64_t out_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_OUT_BLOCK_W, out_block_w, 0);
  }
  void add_per_core_m(uint64_t per_core_m) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_PER_CORE_M, per_core_m, 0);
  }
  void add_per_core_n(uint64_t per_core_n) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_PER_CORE_N, per_core_n, 0);
  }
  void add_fuse_batch(bool fuse_batch) {
    fbb_.AddElement<uint8_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_FUSE_BATCH, static_cast<uint8_t>(fuse_batch), 0);
  }
  void add_fused_activation(::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation) {
    fbb_.AddOffset(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_FUSED_ACTIVATION, fused_activation);
  }
  void add_mcast_in0(bool mcast_in0) {
    fbb_.AddElement<uint8_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_MCAST_IN0, static_cast<uint8_t>(mcast_in0), 0);
  }
  void add_gather_in0(bool gather_in0) {
    fbb_.AddElement<uint8_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_GATHER_IN0, static_cast<uint8_t>(gather_in0), 0);
  }
  void add_hop_cores(::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> hop_cores) {
    fbb_.AddOffset(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_HOP_CORES, hop_cores);
  }
  void add_num_global_cb_receivers(uint64_t num_global_cb_receivers) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCast1DProgramConfig::VT_NUM_GLOBAL_CB_RECEIVERS, num_global_cb_receivers, 0);
  }
  explicit MatmulMultiCoreReuseMultiCast1DProgramConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCast1DProgramConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCast1DProgramConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCast1DProgramConfig> CreateMatmulMultiCoreReuseMultiCast1DProgramConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::ttnn::CoreCoord *compute_with_storage_grid_size = nullptr,
    uint64_t in0_block_w = 0,
    uint64_t out_subblock_h = 0,
    uint64_t out_subblock_w = 0,
    uint64_t out_block_h = 0,
    uint64_t out_block_w = 0,
    uint64_t per_core_m = 0,
    uint64_t per_core_n = 0,
    bool fuse_batch = false,
    ::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation = 0,
    bool mcast_in0 = false,
    bool gather_in0 = false,
    ::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> hop_cores = 0,
    uint64_t num_global_cb_receivers = 0) {
  MatmulMultiCoreReuseMultiCast1DProgramConfigBuilder builder_(_fbb);
  builder_.add_num_global_cb_receivers(num_global_cb_receivers);
  builder_.add_per_core_n(per_core_n);
  builder_.add_per_core_m(per_core_m);
  builder_.add_out_block_w(out_block_w);
  builder_.add_out_block_h(out_block_h);
  builder_.add_out_subblock_w(out_subblock_w);
  builder_.add_out_subblock_h(out_subblock_h);
  builder_.add_in0_block_w(in0_block_w);
  builder_.add_hop_cores(hop_cores);
  builder_.add_fused_activation(fused_activation);
  builder_.add_compute_with_storage_grid_size(compute_with_storage_grid_size);
  builder_.add_gather_in0(gather_in0);
  builder_.add_mcast_in0(mcast_in0);
  builder_.add_fuse_batch(fuse_batch);
  return builder_.Finish();
}
 
struct MatmulMultiCoreReuseMultiCast1DProgramConfig::Traits {
  using type = MatmulMultiCoreReuseMultiCast1DProgramConfig;
  static auto constexpr Create = CreateMatmulMultiCoreReuseMultiCast1DProgramConfig;
};
 
struct MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN0_BLOCK_W = 4,
    VT_PER_CORE_M = 6,
    VT_PER_CORE_N = 8,
    VT_FUSED_ACTIVATION = 10
  };
  uint64_t in0_block_w() const {
    return GetField<uint64_t>(VT_IN0_BLOCK_W, 0);
  }
  uint64_t per_core_m() const {
    return GetField<uint64_t>(VT_PER_CORE_M, 0);
  }
  uint64_t per_core_n() const {
    return GetField<uint64_t>(VT_PER_CORE_N, 0);
  }
  const tt::target::ttnn::UnaryWithParam *fused_activation() const {
    return GetPointer<const tt::target::ttnn::UnaryWithParam *>(VT_FUSED_ACTIVATION);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_IN0_BLOCK_W, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_M, 8) &&
           VerifyField<uint64_t>(verifier, VT_PER_CORE_N, 8) &&
           VerifyOffset(verifier, VT_FUSED_ACTIVATION) &&
           verifier.VerifyTable(fused_activation()) &&
           verifier.EndTable();
  }
};
 
struct MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfigBuilder {
  typedef MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in0_block_w(uint64_t in0_block_w) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig::VT_IN0_BLOCK_W, in0_block_w, 0);
  }
  void add_per_core_m(uint64_t per_core_m) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig::VT_PER_CORE_M, per_core_m, 0);
  }
  void add_per_core_n(uint64_t per_core_n) {
    fbb_.AddElement<uint64_t>(MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig::VT_PER_CORE_N, per_core_n, 0);
  }
  void add_fused_activation(::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation) {
    fbb_.AddOffset(MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig::VT_FUSED_ACTIVATION, fused_activation);
  }
  explicit MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig> CreateMatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t in0_block_w = 0,
    uint64_t per_core_m = 0,
    uint64_t per_core_n = 0,
    ::flatbuffers::Offset<tt::target::ttnn::UnaryWithParam> fused_activation = 0) {
  MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfigBuilder builder_(_fbb);
  builder_.add_per_core_n(per_core_n);
  builder_.add_per_core_m(per_core_m);
  builder_.add_in0_block_w(in0_block_w);
  builder_.add_fused_activation(fused_activation);
  return builder_.Finish();
}
 
struct MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig::Traits {
  using type = MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig;
  static auto constexpr Create = CreateMatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig;
};
 
struct MatmulOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MatmulOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.MatmulOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_A = 4,
    VT_B = 6,
    VT_OUT = 8,
    VT_TRANSPOSE_A = 10,
    VT_TRANSPOSE_B = 12,
    VT_MATMUL_PROGRAM_CONFIG_TYPE = 14,
    VT_MATMUL_PROGRAM_CONFIG = 16
  };
  const tt::target::ttnn::TensorRef *a() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_A);
  }
  const tt::target::ttnn::TensorRef *b() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_B);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool transpose_a() const {
    return GetField<uint8_t>(VT_TRANSPOSE_A, 0) != 0;
  }
  bool transpose_b() const {
    return GetField<uint8_t>(VT_TRANSPOSE_B, 0) != 0;
  }
  tt::target::ttnn::MatmulProgramConfig matmul_program_config_type() const {
    return static_cast<tt::target::ttnn::MatmulProgramConfig>(GetField<uint8_t>(VT_MATMUL_PROGRAM_CONFIG_TYPE, 0));
  }
  const void *matmul_program_config() const {
    return GetPointer<const void *>(VT_MATMUL_PROGRAM_CONFIG);
  }
  template<typename T> const T *matmul_program_config_as() const;
  const tt::target::ttnn::MatmulMultiCoreReuseProgramConfig *matmul_program_config_as_MatmulMultiCoreReuseProgramConfig() const {
    return matmul_program_config_type() == tt::target::ttnn::MatmulProgramConfig::MatmulMultiCoreReuseProgramConfig ? static_cast<const tt::target::ttnn::MatmulMultiCoreReuseProgramConfig *>(matmul_program_config()) : nullptr;
  }
  const tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig *matmul_program_config_as_MatmulMultiCoreReuseMultiCastProgramConfig() const {
    return matmul_program_config_type() == tt::target::ttnn::MatmulProgramConfig::MatmulMultiCoreReuseMultiCastProgramConfig ? static_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig *>(matmul_program_config()) : nullptr;
  }
  const tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig *matmul_program_config_as_MatmulMultiCoreReuseMultiCast1DProgramConfig() const {
    return matmul_program_config_type() == tt::target::ttnn::MatmulProgramConfig::MatmulMultiCoreReuseMultiCast1DProgramConfig ? static_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig *>(matmul_program_config()) : nullptr;
  }
  const tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig *matmul_program_config_as_MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig() const {
    return matmul_program_config_type() == tt::target::ttnn::MatmulProgramConfig::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig ? static_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig *>(matmul_program_config()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_A) &&
           verifier.VerifyTable(a()) &&
           VerifyOffset(verifier, VT_B) &&
           verifier.VerifyTable(b()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_A, 1) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_B, 1) &&
           VerifyField<uint8_t>(verifier, VT_MATMUL_PROGRAM_CONFIG_TYPE, 1) &&
           VerifyOffset(verifier, VT_MATMUL_PROGRAM_CONFIG) &&
           VerifyMatmulProgramConfig(verifier, matmul_program_config(), matmul_program_config_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::MatmulMultiCoreReuseProgramConfig *MatmulOp::matmul_program_config_as<tt::target::ttnn::MatmulMultiCoreReuseProgramConfig>() const {
  return matmul_program_config_as_MatmulMultiCoreReuseProgramConfig();
}
 
template<> inline const tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig *MatmulOp::matmul_program_config_as<tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig>() const {
  return matmul_program_config_as_MatmulMultiCoreReuseMultiCastProgramConfig();
}
 
template<> inline const tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig *MatmulOp::matmul_program_config_as<tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig>() const {
  return matmul_program_config_as_MatmulMultiCoreReuseMultiCast1DProgramConfig();
}
 
template<> inline const tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig *MatmulOp::matmul_program_config_as<tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig>() const {
  return matmul_program_config_as_MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig();
}
 
struct MatmulOpBuilder {
  typedef MatmulOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_a(::flatbuffers::Offset<tt::target::ttnn::TensorRef> a) {
    fbb_.AddOffset(MatmulOp::VT_A, a);
  }
  void add_b(::flatbuffers::Offset<tt::target::ttnn::TensorRef> b) {
    fbb_.AddOffset(MatmulOp::VT_B, b);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(MatmulOp::VT_OUT, out);
  }
  void add_transpose_a(bool transpose_a) {
    fbb_.AddElement<uint8_t>(MatmulOp::VT_TRANSPOSE_A, static_cast<uint8_t>(transpose_a), 0);
  }
  void add_transpose_b(bool transpose_b) {
    fbb_.AddElement<uint8_t>(MatmulOp::VT_TRANSPOSE_B, static_cast<uint8_t>(transpose_b), 0);
  }
  void add_matmul_program_config_type(tt::target::ttnn::MatmulProgramConfig matmul_program_config_type) {
    fbb_.AddElement<uint8_t>(MatmulOp::VT_MATMUL_PROGRAM_CONFIG_TYPE, static_cast<uint8_t>(matmul_program_config_type), 0);
  }
  void add_matmul_program_config(::flatbuffers::Offset<void> matmul_program_config) {
    fbb_.AddOffset(MatmulOp::VT_MATMUL_PROGRAM_CONFIG, matmul_program_config);
  }
  explicit MatmulOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MatmulOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MatmulOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MatmulOp> CreateMatmulOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> a = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> b = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    bool transpose_a = false,
    bool transpose_b = false,
    tt::target::ttnn::MatmulProgramConfig matmul_program_config_type = tt::target::ttnn::MatmulProgramConfig::NONE,
    ::flatbuffers::Offset<void> matmul_program_config = 0) {
  MatmulOpBuilder builder_(_fbb);
  builder_.add_matmul_program_config(matmul_program_config);
  builder_.add_out(out);
  builder_.add_b(b);
  builder_.add_a(a);
  builder_.add_matmul_program_config_type(matmul_program_config_type);
  builder_.add_transpose_b(transpose_b);
  builder_.add_transpose_a(transpose_a);
  return builder_.Finish();
}
 
struct MatmulOp::Traits {
  using type = MatmulOp;
  static auto constexpr Create = CreateMatmulOp;
};
 
struct LinearOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LinearOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.LinearOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_A = 4,
    VT_B = 6,
    VT_BIAS = 8,
    VT_OUT = 10,
    VT_TRANSPOSE_A = 12,
    VT_TRANSPOSE_B = 14
  };
  const tt::target::ttnn::TensorRef *a() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_A);
  }
  const tt::target::ttnn::TensorRef *b() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_B);
  }
  const tt::target::ttnn::TensorRef *bias() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_BIAS);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool transpose_a() const {
    return GetField<uint8_t>(VT_TRANSPOSE_A, 0) != 0;
  }
  bool transpose_b() const {
    return GetField<uint8_t>(VT_TRANSPOSE_B, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_A) &&
           verifier.VerifyTable(a()) &&
           VerifyOffset(verifier, VT_B) &&
           verifier.VerifyTable(b()) &&
           VerifyOffset(verifier, VT_BIAS) &&
           verifier.VerifyTable(bias()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_A, 1) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_B, 1) &&
           verifier.EndTable();
  }
};
 
struct LinearOpBuilder {
  typedef LinearOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_a(::flatbuffers::Offset<tt::target::ttnn::TensorRef> a) {
    fbb_.AddOffset(LinearOp::VT_A, a);
  }
  void add_b(::flatbuffers::Offset<tt::target::ttnn::TensorRef> b) {
    fbb_.AddOffset(LinearOp::VT_B, b);
  }
  void add_bias(::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias) {
    fbb_.AddOffset(LinearOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(LinearOp::VT_OUT, out);
  }
  void add_transpose_a(bool transpose_a) {
    fbb_.AddElement<uint8_t>(LinearOp::VT_TRANSPOSE_A, static_cast<uint8_t>(transpose_a), 0);
  }
  void add_transpose_b(bool transpose_b) {
    fbb_.AddElement<uint8_t>(LinearOp::VT_TRANSPOSE_B, static_cast<uint8_t>(transpose_b), 0);
  }
  explicit LinearOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LinearOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LinearOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LinearOp> CreateLinearOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> a = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> b = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    bool transpose_a = false,
    bool transpose_b = false) {
  LinearOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_bias(bias);
  builder_.add_b(b);
  builder_.add_a(a);
  builder_.add_transpose_b(transpose_b);
  builder_.add_transpose_a(transpose_a);
  return builder_.Finish();
}
 
struct LinearOp::Traits {
  using type = LinearOp;
  static auto constexpr Create = CreateLinearOp;
};
 
inline bool VerifyMatmulProgramConfig(::flatbuffers::Verifier &verifier, const void *obj, MatmulProgramConfig type) {
  switch (type) {
    case MatmulProgramConfig::NONE: {
      return true;
    }
    case MatmulProgramConfig::MatmulMultiCoreReuseProgramConfig: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MatmulMultiCoreReuseProgramConfig *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case MatmulProgramConfig::MatmulMultiCoreReuseMultiCastProgramConfig: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCastProgramConfig *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case MatmulProgramConfig::MatmulMultiCoreReuseMultiCast1DProgramConfig: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCast1DProgramConfig *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case MatmulProgramConfig::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::MatmulMultiCoreReuseMultiCastDRAMShardedProgramConfig *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyMatmulProgramConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<MatmulProgramConfig> *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 (!VerifyMatmulProgramConfig(
        verifier,  values->Get(i), types->GetEnum<MatmulProgramConfig>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_MATMUL_TT_TARGET_TTNN_H_