conv_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_CONV_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_CONV_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 Conv2dConfig;
struct Conv2dConfigBuilder;
 
struct PrepareConv2dWeightsOp;
struct PrepareConv2dWeightsOpBuilder;
 
struct Conv2dOp;
struct Conv2dOpBuilder;
 
struct ConvTranspose2dOp;
struct ConvTranspose2dOpBuilder;
 
struct Conv2dConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Conv2dConfigBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DTYPE = 4,
    VT_WEIGHTS_DTYPE = 6,
    VT_ACTIVATION = 8,
    VT_INPUT_CHANNELS_ALIGNMENT = 10,
    VT_DEALLOCATE_ACTIVATION = 12,
    VT_REALLOCATE_HALO_OUTPUT = 14,
    VT_ACT_BLOCK_H_OVERRIDE = 16,
    VT_ACT_BLOCK_W_DIV = 18,
    VT_RESHARD_IF_NOT_OPTIMAL = 20,
    VT_OVERRIDE_SHARDING_CONFIG = 22,
    VT_SHARD_LAYOUT = 24,
    VT_CORE_GRID = 26,
    VT_TRANSPOSE_SHARDS = 28,
    VT_OUTPUT_LAYOUT = 30,
    VT_PREPROCESS_WEIGHTS_ON_DEVICE = 32,
    VT_ALWAYS_PREPROCESS_WEIGHTS = 34,
    VT_ENABLE_ACT_DOUBLE_BUFFER = 36,
    VT_ENABLE_WEIGHTS_DOUBLE_BUFFER = 38,
    VT_ENABLE_SPLIT_READER = 40,
    VT_ENABLE_SUBBLOCK_PADDING = 42
  };
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  tt::target::DataType weights_dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_WEIGHTS_DTYPE, 0));
  }
  const ::flatbuffers::String *activation() const {
    return GetPointer<const ::flatbuffers::String *>(VT_ACTIVATION);
  }
  uint32_t input_channels_alignment() const {
    return GetField<uint32_t>(VT_INPUT_CHANNELS_ALIGNMENT, 0);
  }
  bool deallocate_activation() const {
    return GetField<uint8_t>(VT_DEALLOCATE_ACTIVATION, 0) != 0;
  }
  bool reallocate_halo_output() const {
    return GetField<uint8_t>(VT_REALLOCATE_HALO_OUTPUT, 0) != 0;
  }
  uint32_t act_block_h_override() const {
    return GetField<uint32_t>(VT_ACT_BLOCK_H_OVERRIDE, 0);
  }
  uint32_t act_block_w_div() const {
    return GetField<uint32_t>(VT_ACT_BLOCK_W_DIV, 0);
  }
  bool reshard_if_not_optimal() const {
    return GetField<uint8_t>(VT_RESHARD_IF_NOT_OPTIMAL, 0) != 0;
  }
  bool override_sharding_config() const {
    return GetField<uint8_t>(VT_OVERRIDE_SHARDING_CONFIG, 0) != 0;
  }
  ::flatbuffers::Optional<tt::target::ttnn::TensorMemoryLayout> shard_layout() const {
    return GetOptional<uint16_t, tt::target::ttnn::TensorMemoryLayout>(VT_SHARD_LAYOUT);
  }
  const tt::target::ttnn::CoreRangeSet *core_grid() const {
    return GetPointer<const tt::target::ttnn::CoreRangeSet *>(VT_CORE_GRID);
  }
  bool transpose_shards() const {
    return GetField<uint8_t>(VT_TRANSPOSE_SHARDS, 0) != 0;
  }
  tt::target::TensorLayout output_layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_OUTPUT_LAYOUT, 0));
  }
  bool preprocess_weights_on_device() const {
    return GetField<uint8_t>(VT_PREPROCESS_WEIGHTS_ON_DEVICE, 0) != 0;
  }
  bool always_preprocess_weights() const {
    return GetField<uint8_t>(VT_ALWAYS_PREPROCESS_WEIGHTS, 0) != 0;
  }
  bool enable_act_double_buffer() const {
    return GetField<uint8_t>(VT_ENABLE_ACT_DOUBLE_BUFFER, 0) != 0;
  }
  bool enable_weights_double_buffer() const {
    return GetField<uint8_t>(VT_ENABLE_WEIGHTS_DOUBLE_BUFFER, 0) != 0;
  }
  bool enable_split_reader() const {
    return GetField<uint8_t>(VT_ENABLE_SPLIT_READER, 0) != 0;
  }
  bool enable_subblock_padding() const {
    return GetField<uint8_t>(VT_ENABLE_SUBBLOCK_PADDING, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_WEIGHTS_DTYPE, 2) &&
           VerifyOffset(verifier, VT_ACTIVATION) &&
           verifier.VerifyString(activation()) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_CHANNELS_ALIGNMENT, 4) &&
           VerifyField<uint8_t>(verifier, VT_DEALLOCATE_ACTIVATION, 1) &&
           VerifyField<uint8_t>(verifier, VT_REALLOCATE_HALO_OUTPUT, 1) &&
           VerifyField<uint32_t>(verifier, VT_ACT_BLOCK_H_OVERRIDE, 4) &&
           VerifyField<uint32_t>(verifier, VT_ACT_BLOCK_W_DIV, 4) &&
           VerifyField<uint8_t>(verifier, VT_RESHARD_IF_NOT_OPTIMAL, 1) &&
           VerifyField<uint8_t>(verifier, VT_OVERRIDE_SHARDING_CONFIG, 1) &&
           VerifyField<uint16_t>(verifier, VT_SHARD_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_CORE_GRID) &&
           verifier.VerifyTable(core_grid()) &&
           VerifyField<uint8_t>(verifier, VT_TRANSPOSE_SHARDS, 1) &&
           VerifyField<uint16_t>(verifier, VT_OUTPUT_LAYOUT, 2) &&
           VerifyField<uint8_t>(verifier, VT_PREPROCESS_WEIGHTS_ON_DEVICE, 1) &&
           VerifyField<uint8_t>(verifier, VT_ALWAYS_PREPROCESS_WEIGHTS, 1) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE_ACT_DOUBLE_BUFFER, 1) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE_WEIGHTS_DOUBLE_BUFFER, 1) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE_SPLIT_READER, 1) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE_SUBBLOCK_PADDING, 1) &&
           verifier.EndTable();
  }
};
 
struct Conv2dConfigBuilder {
  typedef Conv2dConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(Conv2dConfig::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_weights_dtype(tt::target::DataType weights_dtype) {
    fbb_.AddElement<uint16_t>(Conv2dConfig::VT_WEIGHTS_DTYPE, static_cast<uint16_t>(weights_dtype), 0);
  }
  void add_activation(::flatbuffers::Offset<::flatbuffers::String> activation) {
    fbb_.AddOffset(Conv2dConfig::VT_ACTIVATION, activation);
  }
  void add_input_channels_alignment(uint32_t input_channels_alignment) {
    fbb_.AddElement<uint32_t>(Conv2dConfig::VT_INPUT_CHANNELS_ALIGNMENT, input_channels_alignment, 0);
  }
  void add_deallocate_activation(bool deallocate_activation) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_DEALLOCATE_ACTIVATION, static_cast<uint8_t>(deallocate_activation), 0);
  }
  void add_reallocate_halo_output(bool reallocate_halo_output) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_REALLOCATE_HALO_OUTPUT, static_cast<uint8_t>(reallocate_halo_output), 0);
  }
  void add_act_block_h_override(uint32_t act_block_h_override) {
    fbb_.AddElement<uint32_t>(Conv2dConfig::VT_ACT_BLOCK_H_OVERRIDE, act_block_h_override, 0);
  }
  void add_act_block_w_div(uint32_t act_block_w_div) {
    fbb_.AddElement<uint32_t>(Conv2dConfig::VT_ACT_BLOCK_W_DIV, act_block_w_div, 0);
  }
  void add_reshard_if_not_optimal(bool reshard_if_not_optimal) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_RESHARD_IF_NOT_OPTIMAL, static_cast<uint8_t>(reshard_if_not_optimal), 0);
  }
  void add_override_sharding_config(bool override_sharding_config) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_OVERRIDE_SHARDING_CONFIG, static_cast<uint8_t>(override_sharding_config), 0);
  }
  void add_shard_layout(tt::target::ttnn::TensorMemoryLayout shard_layout) {
    fbb_.AddElement<uint16_t>(Conv2dConfig::VT_SHARD_LAYOUT, static_cast<uint16_t>(shard_layout));
  }
  void add_core_grid(::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_grid) {
    fbb_.AddOffset(Conv2dConfig::VT_CORE_GRID, core_grid);
  }
  void add_transpose_shards(bool transpose_shards) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_TRANSPOSE_SHARDS, static_cast<uint8_t>(transpose_shards), 0);
  }
  void add_output_layout(tt::target::TensorLayout output_layout) {
    fbb_.AddElement<uint16_t>(Conv2dConfig::VT_OUTPUT_LAYOUT, static_cast<uint16_t>(output_layout), 0);
  }
  void add_preprocess_weights_on_device(bool preprocess_weights_on_device) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_PREPROCESS_WEIGHTS_ON_DEVICE, static_cast<uint8_t>(preprocess_weights_on_device), 0);
  }
  void add_always_preprocess_weights(bool always_preprocess_weights) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_ALWAYS_PREPROCESS_WEIGHTS, static_cast<uint8_t>(always_preprocess_weights), 0);
  }
  void add_enable_act_double_buffer(bool enable_act_double_buffer) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_ENABLE_ACT_DOUBLE_BUFFER, static_cast<uint8_t>(enable_act_double_buffer), 0);
  }
  void add_enable_weights_double_buffer(bool enable_weights_double_buffer) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_ENABLE_WEIGHTS_DOUBLE_BUFFER, static_cast<uint8_t>(enable_weights_double_buffer), 0);
  }
  void add_enable_split_reader(bool enable_split_reader) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_ENABLE_SPLIT_READER, static_cast<uint8_t>(enable_split_reader), 0);
  }
  void add_enable_subblock_padding(bool enable_subblock_padding) {
    fbb_.AddElement<uint8_t>(Conv2dConfig::VT_ENABLE_SUBBLOCK_PADDING, static_cast<uint8_t>(enable_subblock_padding), 0);
  }
  explicit Conv2dConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Conv2dConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Conv2dConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Conv2dConfig> CreateConv2dConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::DataType weights_dtype = tt::target::DataType::Float32,
    ::flatbuffers::Offset<::flatbuffers::String> activation = 0,
    uint32_t input_channels_alignment = 0,
    bool deallocate_activation = false,
    bool reallocate_halo_output = false,
    uint32_t act_block_h_override = 0,
    uint32_t act_block_w_div = 0,
    bool reshard_if_not_optimal = false,
    bool override_sharding_config = false,
    ::flatbuffers::Optional<tt::target::ttnn::TensorMemoryLayout> shard_layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_grid = 0,
    bool transpose_shards = false,
    tt::target::TensorLayout output_layout = tt::target::TensorLayout::RowMajor,
    bool preprocess_weights_on_device = false,
    bool always_preprocess_weights = false,
    bool enable_act_double_buffer = false,
    bool enable_weights_double_buffer = false,
    bool enable_split_reader = false,
    bool enable_subblock_padding = false) {
  Conv2dConfigBuilder builder_(_fbb);
  builder_.add_core_grid(core_grid);
  builder_.add_act_block_w_div(act_block_w_div);
  builder_.add_act_block_h_override(act_block_h_override);
  builder_.add_input_channels_alignment(input_channels_alignment);
  builder_.add_activation(activation);
  builder_.add_output_layout(output_layout);
  if(shard_layout) { builder_.add_shard_layout(*shard_layout); }
  builder_.add_weights_dtype(weights_dtype);
  builder_.add_dtype(dtype);
  builder_.add_enable_subblock_padding(enable_subblock_padding);
  builder_.add_enable_split_reader(enable_split_reader);
  builder_.add_enable_weights_double_buffer(enable_weights_double_buffer);
  builder_.add_enable_act_double_buffer(enable_act_double_buffer);
  builder_.add_always_preprocess_weights(always_preprocess_weights);
  builder_.add_preprocess_weights_on_device(preprocess_weights_on_device);
  builder_.add_transpose_shards(transpose_shards);
  builder_.add_override_sharding_config(override_sharding_config);
  builder_.add_reshard_if_not_optimal(reshard_if_not_optimal);
  builder_.add_reallocate_halo_output(reallocate_halo_output);
  builder_.add_deallocate_activation(deallocate_activation);
  return builder_.Finish();
}
 
struct Conv2dConfig::Traits {
  using type = Conv2dConfig;
  static auto constexpr Create = CreateConv2dConfig;
};
 
inline ::flatbuffers::Offset<Conv2dConfig> CreateConv2dConfigDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    tt::target::DataType weights_dtype = tt::target::DataType::Float32,
    const char *activation = nullptr,
    uint32_t input_channels_alignment = 0,
    bool deallocate_activation = false,
    bool reallocate_halo_output = false,
    uint32_t act_block_h_override = 0,
    uint32_t act_block_w_div = 0,
    bool reshard_if_not_optimal = false,
    bool override_sharding_config = false,
    ::flatbuffers::Optional<tt::target::ttnn::TensorMemoryLayout> shard_layout = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::CoreRangeSet> core_grid = 0,
    bool transpose_shards = false,
    tt::target::TensorLayout output_layout = tt::target::TensorLayout::RowMajor,
    bool preprocess_weights_on_device = false,
    bool always_preprocess_weights = false,
    bool enable_act_double_buffer = false,
    bool enable_weights_double_buffer = false,
    bool enable_split_reader = false,
    bool enable_subblock_padding = false) {
  auto activation__ = activation ? _fbb.CreateString(activation) : 0;
  return tt::target::ttnn::CreateConv2dConfig(
      _fbb,
      dtype,
      weights_dtype,
      activation__,
      input_channels_alignment,
      deallocate_activation,
      reallocate_halo_output,
      act_block_h_override,
      act_block_w_div,
      reshard_if_not_optimal,
      override_sharding_config,
      shard_layout,
      core_grid,
      transpose_shards,
      output_layout,
      preprocess_weights_on_device,
      always_preprocess_weights,
      enable_act_double_buffer,
      enable_weights_double_buffer,
      enable_split_reader,
      enable_subblock_padding);
}
 
struct PrepareConv2dWeightsOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PrepareConv2dWeightsOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WEIGHT_TENSOR = 4,
    VT_OUT = 6,
    VT_INPUT_MEMORY_CONFIG = 8,
    VT_INPUT_TENSOR_LAYOUT = 10,
    VT_WEIGHTS_FORMAT = 12,
    VT_IN_CHANNELS = 14,
    VT_OUT_CHANNELS = 16,
    VT_BATCH_SIZE = 18,
    VT_INPUT_HEIGHT = 20,
    VT_INPUT_WIDTH = 22,
    VT_KERNEL_SIZE = 24,
    VT_STRIDE = 26,
    VT_PADDING = 28,
    VT_DILATION = 30,
    VT_HAS_BIAS = 32,
    VT_GROUPS = 34,
    VT_DEVICE = 36,
    VT_CONV2D_CONFIG = 38
  };
  const tt::target::ttnn::TensorRef *weight_tensor() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_WEIGHT_TENSOR);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  const tt::target::ttnn::MemoryConfig *input_memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_INPUT_MEMORY_CONFIG);
  }
  tt::target::TensorLayout input_tensor_layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_INPUT_TENSOR_LAYOUT, 0));
  }
  const ::flatbuffers::String *weights_format() const {
    return GetPointer<const ::flatbuffers::String *>(VT_WEIGHTS_FORMAT);
  }
  uint32_t in_channels() const {
    return GetField<uint32_t>(VT_IN_CHANNELS, 0);
  }
  uint32_t out_channels() const {
    return GetField<uint32_t>(VT_OUT_CHANNELS, 0);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  const ::flatbuffers::Vector<int32_t> *kernel_size() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_KERNEL_SIZE);
  }
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  const ::flatbuffers::Vector<int32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DILATION);
  }
  bool has_bias() const {
    return GetField<uint8_t>(VT_HAS_BIAS, 0) != 0;
  }
  uint32_t groups() const {
    return GetField<uint32_t>(VT_GROUPS, 0);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::Conv2dConfig *conv2d_config() const {
    return GetPointer<const tt::target::ttnn::Conv2dConfig *>(VT_CONV2D_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WEIGHT_TENSOR) &&
           verifier.VerifyTable(weight_tensor()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_INPUT_MEMORY_CONFIG) &&
           verifier.VerifyTable(input_memory_config()) &&
           VerifyField<uint16_t>(verifier, VT_INPUT_TENSOR_LAYOUT, 2) &&
           VerifyOffset(verifier, VT_WEIGHTS_FORMAT) &&
           verifier.VerifyString(weights_format()) &&
           VerifyField<uint32_t>(verifier, VT_IN_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_OUT_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyOffset(verifier, VT_KERNEL_SIZE) &&
           verifier.VerifyVector(kernel_size()) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_DILATION) &&
           verifier.VerifyVector(dilation()) &&
           VerifyField<uint8_t>(verifier, VT_HAS_BIAS, 1) &&
           VerifyField<uint32_t>(verifier, VT_GROUPS, 4) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_CONV2D_CONFIG) &&
           verifier.VerifyTable(conv2d_config()) &&
           verifier.EndTable();
  }
};
 
struct PrepareConv2dWeightsOpBuilder {
  typedef PrepareConv2dWeightsOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_weight_tensor(::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight_tensor) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_WEIGHT_TENSOR, weight_tensor);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_OUT, out);
  }
  void add_input_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> input_memory_config) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_INPUT_MEMORY_CONFIG, input_memory_config);
  }
  void add_input_tensor_layout(tt::target::TensorLayout input_tensor_layout) {
    fbb_.AddElement<uint16_t>(PrepareConv2dWeightsOp::VT_INPUT_TENSOR_LAYOUT, static_cast<uint16_t>(input_tensor_layout), 0);
  }
  void add_weights_format(::flatbuffers::Offset<::flatbuffers::String> weights_format) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_WEIGHTS_FORMAT, weights_format);
  }
  void add_in_channels(uint32_t in_channels) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_IN_CHANNELS, in_channels, 0);
  }
  void add_out_channels(uint32_t out_channels) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_OUT_CHANNELS, out_channels, 0);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_kernel_size(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_KERNEL_SIZE, kernel_size);
  }
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_STRIDE, stride);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_PADDING, padding);
  }
  void add_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_DILATION, dilation);
  }
  void add_has_bias(bool has_bias) {
    fbb_.AddElement<uint8_t>(PrepareConv2dWeightsOp::VT_HAS_BIAS, static_cast<uint8_t>(has_bias), 0);
  }
  void add_groups(uint32_t groups) {
    fbb_.AddElement<uint32_t>(PrepareConv2dWeightsOp::VT_GROUPS, groups, 0);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_DEVICE, device);
  }
  void add_conv2d_config(::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config) {
    fbb_.AddOffset(PrepareConv2dWeightsOp::VT_CONV2D_CONFIG, conv2d_config);
  }
  explicit PrepareConv2dWeightsOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PrepareConv2dWeightsOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PrepareConv2dWeightsOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PrepareConv2dWeightsOp> CreatePrepareConv2dWeightsOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight_tensor = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> input_memory_config = 0,
    tt::target::TensorLayout input_tensor_layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Offset<::flatbuffers::String> weights_format = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation = 0,
    bool has_bias = false,
    uint32_t groups = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config = 0) {
  PrepareConv2dWeightsOpBuilder builder_(_fbb);
  builder_.add_conv2d_config(conv2d_config);
  builder_.add_device(device);
  builder_.add_groups(groups);
  builder_.add_dilation(dilation);
  builder_.add_padding(padding);
  builder_.add_stride(stride);
  builder_.add_kernel_size(kernel_size);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_out_channels(out_channels);
  builder_.add_in_channels(in_channels);
  builder_.add_weights_format(weights_format);
  builder_.add_input_memory_config(input_memory_config);
  builder_.add_out(out);
  builder_.add_weight_tensor(weight_tensor);
  builder_.add_input_tensor_layout(input_tensor_layout);
  builder_.add_has_bias(has_bias);
  return builder_.Finish();
}
 
struct PrepareConv2dWeightsOp::Traits {
  using type = PrepareConv2dWeightsOp;
  static auto constexpr Create = CreatePrepareConv2dWeightsOp;
};
 
inline ::flatbuffers::Offset<PrepareConv2dWeightsOp> CreatePrepareConv2dWeightsOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight_tensor = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> input_memory_config = 0,
    tt::target::TensorLayout input_tensor_layout = tt::target::TensorLayout::RowMajor,
    const char *weights_format = nullptr,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    const std::vector<int32_t> *kernel_size = nullptr,
    const std::vector<int32_t> *stride = nullptr,
    const std::vector<int32_t> *padding = nullptr,
    const std::vector<int32_t> *dilation = nullptr,
    bool has_bias = false,
    uint32_t groups = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config = 0) {
  auto weights_format__ = weights_format ? _fbb.CreateString(weights_format) : 0;
  auto kernel_size__ = kernel_size ? _fbb.CreateVector<int32_t>(*kernel_size) : 0;
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
  auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
  return tt::target::ttnn::CreatePrepareConv2dWeightsOp(
      _fbb,
      weight_tensor,
      out,
      input_memory_config,
      input_tensor_layout,
      weights_format__,
      in_channels,
      out_channels,
      batch_size,
      input_height,
      input_width,
      kernel_size__,
      stride__,
      padding__,
      dilation__,
      has_bias,
      groups,
      device,
      conv2d_config);
}
 
struct Conv2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Conv2dOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_BIAS = 8,
    VT_OUT = 10,
    VT_DEVICE = 12,
    VT_IN_CHANNELS = 14,
    VT_OUT_CHANNELS = 16,
    VT_BATCH_SIZE = 18,
    VT_INPUT_HEIGHT = 20,
    VT_INPUT_WIDTH = 22,
    VT_KERNEL_SIZE = 24,
    VT_STRIDE = 26,
    VT_PADDING = 28,
    VT_DILATION = 30,
    VT_GROUPS = 32,
    VT_CONV2D_CONFIG = 34
  };
  const tt::target::ttnn::TensorRef *input() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_INPUT);
  }
  const tt::target::ttnn::TensorRef *weight() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_WEIGHT);
  }
  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);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  uint32_t in_channels() const {
    return GetField<uint32_t>(VT_IN_CHANNELS, 0);
  }
  uint32_t out_channels() const {
    return GetField<uint32_t>(VT_OUT_CHANNELS, 0);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  const ::flatbuffers::Vector<int32_t> *kernel_size() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_KERNEL_SIZE);
  }
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  const ::flatbuffers::Vector<int32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DILATION);
  }
  uint32_t groups() const {
    return GetField<uint32_t>(VT_GROUPS, 0);
  }
  const tt::target::ttnn::Conv2dConfig *conv2d_config() const {
    return GetPointer<const tt::target::ttnn::Conv2dConfig *>(VT_CONV2D_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_BIAS) &&
           verifier.VerifyTable(bias()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_IN_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_OUT_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyOffset(verifier, VT_KERNEL_SIZE) &&
           verifier.VerifyVector(kernel_size()) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_DILATION) &&
           verifier.VerifyVector(dilation()) &&
           VerifyField<uint32_t>(verifier, VT_GROUPS, 4) &&
           VerifyOffset(verifier, VT_CONV2D_CONFIG) &&
           verifier.VerifyTable(conv2d_config()) &&
           verifier.EndTable();
  }
};
 
struct Conv2dOpBuilder {
  typedef Conv2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::ttnn::TensorRef> input) {
    fbb_.AddOffset(Conv2dOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight) {
    fbb_.AddOffset(Conv2dOp::VT_WEIGHT, weight);
  }
  void add_bias(::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias) {
    fbb_.AddOffset(Conv2dOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(Conv2dOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(Conv2dOp::VT_DEVICE, device);
  }
  void add_in_channels(uint32_t in_channels) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_IN_CHANNELS, in_channels, 0);
  }
  void add_out_channels(uint32_t out_channels) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_OUT_CHANNELS, out_channels, 0);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_kernel_size(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size) {
    fbb_.AddOffset(Conv2dOp::VT_KERNEL_SIZE, kernel_size);
  }
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(Conv2dOp::VT_STRIDE, stride);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
    fbb_.AddOffset(Conv2dOp::VT_PADDING, padding);
  }
  void add_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation) {
    fbb_.AddOffset(Conv2dOp::VT_DILATION, dilation);
  }
  void add_groups(uint32_t groups) {
    fbb_.AddElement<uint32_t>(Conv2dOp::VT_GROUPS, groups, 0);
  }
  void add_conv2d_config(::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config) {
    fbb_.AddOffset(Conv2dOp::VT_CONV2D_CONFIG, conv2d_config);
  }
  explicit Conv2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Conv2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Conv2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Conv2dOp> CreateConv2dOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation = 0,
    uint32_t groups = 0,
    ::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config = 0) {
  Conv2dOpBuilder builder_(_fbb);
  builder_.add_conv2d_config(conv2d_config);
  builder_.add_groups(groups);
  builder_.add_dilation(dilation);
  builder_.add_padding(padding);
  builder_.add_stride(stride);
  builder_.add_kernel_size(kernel_size);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_out_channels(out_channels);
  builder_.add_in_channels(in_channels);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_bias(bias);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct Conv2dOp::Traits {
  using type = Conv2dOp;
  static auto constexpr Create = CreateConv2dOp;
};
 
inline ::flatbuffers::Offset<Conv2dOp> CreateConv2dOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    const std::vector<int32_t> *kernel_size = nullptr,
    const std::vector<int32_t> *stride = nullptr,
    const std::vector<int32_t> *padding = nullptr,
    const std::vector<int32_t> *dilation = nullptr,
    uint32_t groups = 0,
    ::flatbuffers::Offset<tt::target::ttnn::Conv2dConfig> conv2d_config = 0) {
  auto kernel_size__ = kernel_size ? _fbb.CreateVector<int32_t>(*kernel_size) : 0;
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
  auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
  return tt::target::ttnn::CreateConv2dOp(
      _fbb,
      input,
      weight,
      bias,
      out,
      device,
      in_channels,
      out_channels,
      batch_size,
      input_height,
      input_width,
      kernel_size__,
      stride__,
      padding__,
      dilation__,
      groups,
      conv2d_config);
}
 
struct ConvTranspose2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ConvTranspose2dOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_BIAS = 8,
    VT_OUT = 10,
    VT_DEVICE = 12,
    VT_IN_CHANNELS = 14,
    VT_OUT_CHANNELS = 16,
    VT_BATCH_SIZE = 18,
    VT_INPUT_HEIGHT = 20,
    VT_INPUT_WIDTH = 22,
    VT_KERNEL_SIZE = 24,
    VT_STRIDE = 26,
    VT_PADDING = 28,
    VT_OUTPUT_PADDING = 30,
    VT_DILATION = 32,
    VT_GROUPS = 34
  };
  const tt::target::ttnn::TensorRef *input() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_INPUT);
  }
  const tt::target::ttnn::TensorRef *weight() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_WEIGHT);
  }
  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);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  uint32_t in_channels() const {
    return GetField<uint32_t>(VT_IN_CHANNELS, 0);
  }
  uint32_t out_channels() const {
    return GetField<uint32_t>(VT_OUT_CHANNELS, 0);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  const ::flatbuffers::Vector<int32_t> *kernel_size() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_KERNEL_SIZE);
  }
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  const ::flatbuffers::Vector<int32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *output_padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_OUTPUT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DILATION);
  }
  uint32_t groups() const {
    return GetField<uint32_t>(VT_GROUPS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_BIAS) &&
           verifier.VerifyTable(bias()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_IN_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_OUT_CHANNELS, 4) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyOffset(verifier, VT_KERNEL_SIZE) &&
           verifier.VerifyVector(kernel_size()) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_OUTPUT_PADDING) &&
           verifier.VerifyVector(output_padding()) &&
           VerifyOffset(verifier, VT_DILATION) &&
           verifier.VerifyVector(dilation()) &&
           VerifyField<uint32_t>(verifier, VT_GROUPS, 4) &&
           verifier.EndTable();
  }
};
 
struct ConvTranspose2dOpBuilder {
  typedef ConvTranspose2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::ttnn::TensorRef> input) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_WEIGHT, weight);
  }
  void add_bias(::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_BIAS, bias);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_OUT, out);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_DEVICE, device);
  }
  void add_in_channels(uint32_t in_channels) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_IN_CHANNELS, in_channels, 0);
  }
  void add_out_channels(uint32_t out_channels) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_OUT_CHANNELS, out_channels, 0);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_kernel_size(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_KERNEL_SIZE, kernel_size);
  }
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_STRIDE, stride);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_PADDING, padding);
  }
  void add_output_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> output_padding) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_OUTPUT_PADDING, output_padding);
  }
  void add_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation) {
    fbb_.AddOffset(ConvTranspose2dOp::VT_DILATION, dilation);
  }
  void add_groups(uint32_t groups) {
    fbb_.AddElement<uint32_t>(ConvTranspose2dOp::VT_GROUPS, groups, 0);
  }
  explicit ConvTranspose2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ConvTranspose2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ConvTranspose2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ConvTranspose2dOp> CreateConvTranspose2dOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> output_padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation = 0,
    uint32_t groups = 0) {
  ConvTranspose2dOpBuilder builder_(_fbb);
  builder_.add_groups(groups);
  builder_.add_dilation(dilation);
  builder_.add_output_padding(output_padding);
  builder_.add_padding(padding);
  builder_.add_stride(stride);
  builder_.add_kernel_size(kernel_size);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_out_channels(out_channels);
  builder_.add_in_channels(in_channels);
  builder_.add_device(device);
  builder_.add_out(out);
  builder_.add_bias(bias);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct ConvTranspose2dOp::Traits {
  using type = ConvTranspose2dOp;
  static auto constexpr Create = CreateConvTranspose2dOp;
};
 
inline ::flatbuffers::Offset<ConvTranspose2dOp> CreateConvTranspose2dOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> bias = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t in_channels = 0,
    uint32_t out_channels = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    const std::vector<int32_t> *kernel_size = nullptr,
    const std::vector<int32_t> *stride = nullptr,
    const std::vector<int32_t> *padding = nullptr,
    const std::vector<int32_t> *output_padding = nullptr,
    const std::vector<int32_t> *dilation = nullptr,
    uint32_t groups = 0) {
  auto kernel_size__ = kernel_size ? _fbb.CreateVector<int32_t>(*kernel_size) : 0;
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
  auto output_padding__ = output_padding ? _fbb.CreateVector<int32_t>(*output_padding) : 0;
  auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
  return tt::target::ttnn::CreateConvTranspose2dOp(
      _fbb,
      input,
      weight,
      bias,
      out,
      device,
      in_channels,
      out_channels,
      batch_size,
      input_height,
      input_width,
      kernel_size__,
      stride__,
      padding__,
      output_padding__,
      dilation__,
      groups);
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_CONV_TT_TARGET_TTNN_H_