eltwise_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_ELTWISE_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_ELTWISE_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 EltwiseOpWithFloatParams;
struct EltwiseOpWithFloatParamsBuilder;
 
struct EltwiseBinaryOp;
struct EltwiseBinaryOpBuilder;
 
struct EltwiseBinaryCompositeOp;
struct EltwiseBinaryCompositeOpBuilder;
 
struct PerTensorScale;
struct PerTensorScaleBuilder;
 
struct PerAxisScale;
struct PerAxisScaleBuilder;
 
struct PerTensorZeroPoint;
struct PerTensorZeroPointBuilder;
 
struct PerAxisZeroPoint;
struct PerAxisZeroPointBuilder;
 
struct QuantizeDequantizeOpParams;
struct QuantizeDequantizeOpParamsBuilder;
 
struct RequantizeOpParams;
struct RequantizeOpParamsBuilder;
 
struct EltwiseQuantizationOp;
struct EltwiseQuantizationOpBuilder;
 
struct EltwiseTernaryWhereOp;
struct EltwiseTernaryWhereOpBuilder;
 
struct EltwiseUnaryOp;
struct EltwiseUnaryOpBuilder;
 
struct ClampScalarOpParams;
struct ClampScalarOpParamsBuilder;
 
struct ClampTensorOpParams;
struct ClampTensorOpParamsBuilder;
 
struct EltwiseUnaryCompositeOp;
struct EltwiseUnaryCompositeOpBuilder;
 
struct UnaryWithParam;
struct UnaryWithParamBuilder;
 
enum class EltwiseBinaryOpType : uint32_t {
  Add = 0,
  Multiply = 1,
  Subtract = 2,
  Equal = 3,
  NotEqual = 4,
  GreaterEqual = 5,
  GreaterThan = 6,
  LessEqual = 7,
  LessThan = 8,
  Divide = 9,
  LogicalAnd = 10,
  LogicalOr = 11,
  LogicalXor = 12,
  MIN = Add,
  MAX = LogicalXor
};
 
inline const EltwiseBinaryOpType (&EnumValuesEltwiseBinaryOpType())[13] {
  static const EltwiseBinaryOpType values[] = {
    EltwiseBinaryOpType::Add,
    EltwiseBinaryOpType::Multiply,
    EltwiseBinaryOpType::Subtract,
    EltwiseBinaryOpType::Equal,
    EltwiseBinaryOpType::NotEqual,
    EltwiseBinaryOpType::GreaterEqual,
    EltwiseBinaryOpType::GreaterThan,
    EltwiseBinaryOpType::LessEqual,
    EltwiseBinaryOpType::LessThan,
    EltwiseBinaryOpType::Divide,
    EltwiseBinaryOpType::LogicalAnd,
    EltwiseBinaryOpType::LogicalOr,
    EltwiseBinaryOpType::LogicalXor
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseBinaryOpType() {
  static const char * const names[14] = {
    "Add",
    "Multiply",
    "Subtract",
    "Equal",
    "NotEqual",
    "GreaterEqual",
    "GreaterThan",
    "LessEqual",
    "LessThan",
    "Divide",
    "LogicalAnd",
    "LogicalOr",
    "LogicalXor",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseBinaryOpType(EltwiseBinaryOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseBinaryOpType::Add, EltwiseBinaryOpType::LogicalXor)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseBinaryOpType()[index];
}
 
enum class EltwiseBinaryCompositeOpType : uint32_t {
  Maximum = 0,
  Minimum = 1,
  Remainder = 2,
  Scatter = 3,
  Pow = 4,
  Atan2 = 5,
  BitwiseAnd = 6,
  BitwiseOr = 7,
  BitwiseXor = 8,
  MIN = Maximum,
  MAX = BitwiseXor
};
 
inline const EltwiseBinaryCompositeOpType (&EnumValuesEltwiseBinaryCompositeOpType())[9] {
  static const EltwiseBinaryCompositeOpType values[] = {
    EltwiseBinaryCompositeOpType::Maximum,
    EltwiseBinaryCompositeOpType::Minimum,
    EltwiseBinaryCompositeOpType::Remainder,
    EltwiseBinaryCompositeOpType::Scatter,
    EltwiseBinaryCompositeOpType::Pow,
    EltwiseBinaryCompositeOpType::Atan2,
    EltwiseBinaryCompositeOpType::BitwiseAnd,
    EltwiseBinaryCompositeOpType::BitwiseOr,
    EltwiseBinaryCompositeOpType::BitwiseXor
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseBinaryCompositeOpType() {
  static const char * const names[10] = {
    "Maximum",
    "Minimum",
    "Remainder",
    "Scatter",
    "Pow",
    "Atan2",
    "BitwiseAnd",
    "BitwiseOr",
    "BitwiseXor",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseBinaryCompositeOpType(EltwiseBinaryCompositeOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseBinaryCompositeOpType::Maximum, EltwiseBinaryCompositeOpType::BitwiseXor)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseBinaryCompositeOpType()[index];
}
 
enum class EltwiseQuantizationOpType : uint32_t {
  Quantize = 0,
  Dequantize = 1,
  Requantize = 2,
  MIN = Quantize,
  MAX = Requantize
};
 
inline const EltwiseQuantizationOpType (&EnumValuesEltwiseQuantizationOpType())[3] {
  static const EltwiseQuantizationOpType values[] = {
    EltwiseQuantizationOpType::Quantize,
    EltwiseQuantizationOpType::Dequantize,
    EltwiseQuantizationOpType::Requantize
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseQuantizationOpType() {
  static const char * const names[4] = {
    "Quantize",
    "Dequantize",
    "Requantize",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseQuantizationOpType(EltwiseQuantizationOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseQuantizationOpType::Quantize, EltwiseQuantizationOpType::Requantize)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseQuantizationOpType()[index];
}
 
enum class QuantizationScale : uint8_t {
  NONE = 0,
  PerTensorScale = 1,
  PerAxisScale = 2,
  MIN = NONE,
  MAX = PerAxisScale
};
 
inline const QuantizationScale (&EnumValuesQuantizationScale())[3] {
  static const QuantizationScale values[] = {
    QuantizationScale::NONE,
    QuantizationScale::PerTensorScale,
    QuantizationScale::PerAxisScale
  };
  return values;
}
 
inline const char * const *EnumNamesQuantizationScale() {
  static const char * const names[4] = {
    "NONE",
    "PerTensorScale",
    "PerAxisScale",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameQuantizationScale(QuantizationScale e) {
  if (::flatbuffers::IsOutRange(e, QuantizationScale::NONE, QuantizationScale::PerAxisScale)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesQuantizationScale()[index];
}
 
template<typename T> struct QuantizationScaleTraits {
  static const QuantizationScale enum_value = QuantizationScale::NONE;
};
 
template<> struct QuantizationScaleTraits<tt::target::ttnn::PerTensorScale> {
  static const QuantizationScale enum_value = QuantizationScale::PerTensorScale;
};
 
template<> struct QuantizationScaleTraits<tt::target::ttnn::PerAxisScale> {
  static const QuantizationScale enum_value = QuantizationScale::PerAxisScale;
};
 
bool VerifyQuantizationScale(::flatbuffers::Verifier &verifier, const void *obj, QuantizationScale type);
bool VerifyQuantizationScaleVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationScale> *types);
 
enum class QuantizationZeroPoint : uint8_t {
  NONE = 0,
  PerTensorZeroPoint = 1,
  PerAxisZeroPoint = 2,
  MIN = NONE,
  MAX = PerAxisZeroPoint
};
 
inline const QuantizationZeroPoint (&EnumValuesQuantizationZeroPoint())[3] {
  static const QuantizationZeroPoint values[] = {
    QuantizationZeroPoint::NONE,
    QuantizationZeroPoint::PerTensorZeroPoint,
    QuantizationZeroPoint::PerAxisZeroPoint
  };
  return values;
}
 
inline const char * const *EnumNamesQuantizationZeroPoint() {
  static const char * const names[4] = {
    "NONE",
    "PerTensorZeroPoint",
    "PerAxisZeroPoint",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameQuantizationZeroPoint(QuantizationZeroPoint e) {
  if (::flatbuffers::IsOutRange(e, QuantizationZeroPoint::NONE, QuantizationZeroPoint::PerAxisZeroPoint)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesQuantizationZeroPoint()[index];
}
 
template<typename T> struct QuantizationZeroPointTraits {
  static const QuantizationZeroPoint enum_value = QuantizationZeroPoint::NONE;
};
 
template<> struct QuantizationZeroPointTraits<tt::target::ttnn::PerTensorZeroPoint> {
  static const QuantizationZeroPoint enum_value = QuantizationZeroPoint::PerTensorZeroPoint;
};
 
template<> struct QuantizationZeroPointTraits<tt::target::ttnn::PerAxisZeroPoint> {
  static const QuantizationZeroPoint enum_value = QuantizationZeroPoint::PerAxisZeroPoint;
};
 
bool VerifyQuantizationZeroPoint(::flatbuffers::Verifier &verifier, const void *obj, QuantizationZeroPoint type);
bool VerifyQuantizationZeroPointVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationZeroPoint> *types);
 
enum class EltwiseQuantizationOpParams : uint8_t {
  NONE = 0,
  QuantizeDequantizeOpParams = 1,
  RequantizeOpParams = 2,
  MIN = NONE,
  MAX = RequantizeOpParams
};
 
inline const EltwiseQuantizationOpParams (&EnumValuesEltwiseQuantizationOpParams())[3] {
  static const EltwiseQuantizationOpParams values[] = {
    EltwiseQuantizationOpParams::NONE,
    EltwiseQuantizationOpParams::QuantizeDequantizeOpParams,
    EltwiseQuantizationOpParams::RequantizeOpParams
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseQuantizationOpParams() {
  static const char * const names[4] = {
    "NONE",
    "QuantizeDequantizeOpParams",
    "RequantizeOpParams",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseQuantizationOpParams(EltwiseQuantizationOpParams e) {
  if (::flatbuffers::IsOutRange(e, EltwiseQuantizationOpParams::NONE, EltwiseQuantizationOpParams::RequantizeOpParams)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseQuantizationOpParams()[index];
}
 
template<typename T> struct EltwiseQuantizationOpParamsTraits {
  static const EltwiseQuantizationOpParams enum_value = EltwiseQuantizationOpParams::NONE;
};
 
template<> struct EltwiseQuantizationOpParamsTraits<tt::target::ttnn::QuantizeDequantizeOpParams> {
  static const EltwiseQuantizationOpParams enum_value = EltwiseQuantizationOpParams::QuantizeDequantizeOpParams;
};
 
template<> struct EltwiseQuantizationOpParamsTraits<tt::target::ttnn::RequantizeOpParams> {
  static const EltwiseQuantizationOpParams enum_value = EltwiseQuantizationOpParams::RequantizeOpParams;
};
 
bool VerifyEltwiseQuantizationOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseQuantizationOpParams type);
bool VerifyEltwiseQuantizationOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseQuantizationOpParams> *types);
 
enum class EltwiseUnaryOpType : uint32_t {
  Abs = 0,
  Ceil = 1,
  Cos = 2,
  Floor = 3,
  Gelu = 4,
  IsFinite = 5,
  LogicalNot = 6,
  Neg = 7,
  Relu = 8,
  Sqrt = 9,
  Rsqrt = 10,
  Sigmoid = 11,
  Sin = 12,
  Reciprocal = 13,
  Sign = 14,
  Tan = 15,
  Tanh = 16,
  Atan = 17,
  Exp = 18,
  Erf = 19,
  Log = 20,
  Expm1 = 21,
  LeakyRelu = 22,
  BitwiseNot = 23,
  MIN = Abs,
  MAX = BitwiseNot
};
 
inline const EltwiseUnaryOpType (&EnumValuesEltwiseUnaryOpType())[24] {
  static const EltwiseUnaryOpType values[] = {
    EltwiseUnaryOpType::Abs,
    EltwiseUnaryOpType::Ceil,
    EltwiseUnaryOpType::Cos,
    EltwiseUnaryOpType::Floor,
    EltwiseUnaryOpType::Gelu,
    EltwiseUnaryOpType::IsFinite,
    EltwiseUnaryOpType::LogicalNot,
    EltwiseUnaryOpType::Neg,
    EltwiseUnaryOpType::Relu,
    EltwiseUnaryOpType::Sqrt,
    EltwiseUnaryOpType::Rsqrt,
    EltwiseUnaryOpType::Sigmoid,
    EltwiseUnaryOpType::Sin,
    EltwiseUnaryOpType::Reciprocal,
    EltwiseUnaryOpType::Sign,
    EltwiseUnaryOpType::Tan,
    EltwiseUnaryOpType::Tanh,
    EltwiseUnaryOpType::Atan,
    EltwiseUnaryOpType::Exp,
    EltwiseUnaryOpType::Erf,
    EltwiseUnaryOpType::Log,
    EltwiseUnaryOpType::Expm1,
    EltwiseUnaryOpType::LeakyRelu,
    EltwiseUnaryOpType::BitwiseNot
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseUnaryOpType() {
  static const char * const names[25] = {
    "Abs",
    "Ceil",
    "Cos",
    "Floor",
    "Gelu",
    "IsFinite",
    "LogicalNot",
    "Neg",
    "Relu",
    "Sqrt",
    "Rsqrt",
    "Sigmoid",
    "Sin",
    "Reciprocal",
    "Sign",
    "Tan",
    "Tanh",
    "Atan",
    "Exp",
    "Erf",
    "Log",
    "Expm1",
    "LeakyRelu",
    "BitwiseNot",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseUnaryOpType(EltwiseUnaryOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseUnaryOpType::Abs, EltwiseUnaryOpType::BitwiseNot)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseUnaryOpType()[index];
}
 
enum class EltwiseUnaryOpParams : uint8_t {
  NONE = 0,
  EltwiseOpWithFloatParams = 1,
  MIN = NONE,
  MAX = EltwiseOpWithFloatParams
};
 
inline const EltwiseUnaryOpParams (&EnumValuesEltwiseUnaryOpParams())[2] {
  static const EltwiseUnaryOpParams values[] = {
    EltwiseUnaryOpParams::NONE,
    EltwiseUnaryOpParams::EltwiseOpWithFloatParams
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseUnaryOpParams() {
  static const char * const names[3] = {
    "NONE",
    "EltwiseOpWithFloatParams",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseUnaryOpParams(EltwiseUnaryOpParams e) {
  if (::flatbuffers::IsOutRange(e, EltwiseUnaryOpParams::NONE, EltwiseUnaryOpParams::EltwiseOpWithFloatParams)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseUnaryOpParams()[index];
}
 
template<typename T> struct EltwiseUnaryOpParamsTraits {
  static const EltwiseUnaryOpParams enum_value = EltwiseUnaryOpParams::NONE;
};
 
template<> struct EltwiseUnaryOpParamsTraits<tt::target::ttnn::EltwiseOpWithFloatParams> {
  static const EltwiseUnaryOpParams enum_value = EltwiseUnaryOpParams::EltwiseOpWithFloatParams;
};
 
bool VerifyEltwiseUnaryOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseUnaryOpParams type);
bool VerifyEltwiseUnaryOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseUnaryOpParams> *types);
 
enum class EltwiseUnaryCompositeOpType : uint32_t {
  Cbrt = 0,
  ClampScalar = 1,
  ClampTensor = 2,
  Log1p = 3,
  MIN = Cbrt,
  MAX = Log1p
};
 
inline const EltwiseUnaryCompositeOpType (&EnumValuesEltwiseUnaryCompositeOpType())[4] {
  static const EltwiseUnaryCompositeOpType values[] = {
    EltwiseUnaryCompositeOpType::Cbrt,
    EltwiseUnaryCompositeOpType::ClampScalar,
    EltwiseUnaryCompositeOpType::ClampTensor,
    EltwiseUnaryCompositeOpType::Log1p
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseUnaryCompositeOpType() {
  static const char * const names[5] = {
    "Cbrt",
    "ClampScalar",
    "ClampTensor",
    "Log1p",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseUnaryCompositeOpType(EltwiseUnaryCompositeOpType e) {
  if (::flatbuffers::IsOutRange(e, EltwiseUnaryCompositeOpType::Cbrt, EltwiseUnaryCompositeOpType::Log1p)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseUnaryCompositeOpType()[index];
}
 
enum class EltwiseUnaryCompositeOpParams : uint8_t {
  NONE = 0,
  ClampScalarOpParams = 1,
  ClampTensorOpParams = 2,
  MIN = NONE,
  MAX = ClampTensorOpParams
};
 
inline const EltwiseUnaryCompositeOpParams (&EnumValuesEltwiseUnaryCompositeOpParams())[3] {
  static const EltwiseUnaryCompositeOpParams values[] = {
    EltwiseUnaryCompositeOpParams::NONE,
    EltwiseUnaryCompositeOpParams::ClampScalarOpParams,
    EltwiseUnaryCompositeOpParams::ClampTensorOpParams
  };
  return values;
}
 
inline const char * const *EnumNamesEltwiseUnaryCompositeOpParams() {
  static const char * const names[4] = {
    "NONE",
    "ClampScalarOpParams",
    "ClampTensorOpParams",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEltwiseUnaryCompositeOpParams(EltwiseUnaryCompositeOpParams e) {
  if (::flatbuffers::IsOutRange(e, EltwiseUnaryCompositeOpParams::NONE, EltwiseUnaryCompositeOpParams::ClampTensorOpParams)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEltwiseUnaryCompositeOpParams()[index];
}
 
template<typename T> struct EltwiseUnaryCompositeOpParamsTraits {
  static const EltwiseUnaryCompositeOpParams enum_value = EltwiseUnaryCompositeOpParams::NONE;
};
 
template<> struct EltwiseUnaryCompositeOpParamsTraits<tt::target::ttnn::ClampScalarOpParams> {
  static const EltwiseUnaryCompositeOpParams enum_value = EltwiseUnaryCompositeOpParams::ClampScalarOpParams;
};
 
template<> struct EltwiseUnaryCompositeOpParamsTraits<tt::target::ttnn::ClampTensorOpParams> {
  static const EltwiseUnaryCompositeOpParams enum_value = EltwiseUnaryCompositeOpParams::ClampTensorOpParams;
};
 
bool VerifyEltwiseUnaryCompositeOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseUnaryCompositeOpParams type);
bool VerifyEltwiseUnaryCompositeOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseUnaryCompositeOpParams> *types);
 
enum class UnaryOpType : uint32_t {
  Exp = 0,
  Recip = 1,
  Gelu = 2,
  Relu = 3,
  Sqrt = 4,
  Sigmoid = 5,
  Log = 6,
  Tanh = 7,
  Log2 = 8,
  Log10 = 9,
  Sin = 10,
  Cos = 11,
  Abs = 12,
  AbsInt32 = 13,
  Sign = 14,
  Square = 15,
  Eqz = 16,
  Nez = 17,
  Gtz = 18,
  Ltz = 19,
  Gez = 20,
  Lez = 21,
  ReluMax = 22,
  ReluMin = 23,
  Power = 24,
  LeakyRelu = 25,
  Elu = 26,
  Exp2 = 27,
  Heaviside = 28,
  Expm1 = 29,
  Signbit = 30,
  Asin = 31,
  Acos = 32,
  Rsqrt = 33,
  Relu6 = 34,
  Atan = 35,
  Erf = 36,
  Erfc = 37,
  Isinf = 38,
  Isposinf = 39,
  Isneginf = 40,
  Isnan = 41,
  LogicalNotUnary = 42,
  Isfinite = 43,
  Erfinv = 44,
  I0 = 45,
  I1 = 46,
  Tan = 47,
  Rsub = 48,
  Rdiv = 49,
  Silu = 50,
  Softplus = 51,
  Identity = 52,
  Neg = 53,
  AddUnarySfpu = 54,
  SubUnarySfpu = 55,
  MulUnarySfpu = 56,
  DivUnarySfpu = 57,
  IdentityUint32 = 58,
  UnaryNe = 59,
  UnaryGt = 60,
  UnaryLt = 61,
  TiledProd = 62,
  Typecast = 63,
  BitwiseXor = 64,
  BitwiseNot = 65,
  BitwiseAnd = 66,
  BitwiseOr = 67,
  RightShift = 68,
  Floor = 69,
  Ceil = 70,
  Round = 71,
  LeftShift = 72,
  Remainder = 73,
  Fmod = 74,
  Dropout = 75,
  Fill = 76,
  PreluSfpu = 77,
  ZeroPoint = 78,
  MIN = Exp,
  MAX = ZeroPoint
};
 
inline const UnaryOpType (&EnumValuesUnaryOpType())[79] {
  static const UnaryOpType values[] = {
    UnaryOpType::Exp,
    UnaryOpType::Recip,
    UnaryOpType::Gelu,
    UnaryOpType::Relu,
    UnaryOpType::Sqrt,
    UnaryOpType::Sigmoid,
    UnaryOpType::Log,
    UnaryOpType::Tanh,
    UnaryOpType::Log2,
    UnaryOpType::Log10,
    UnaryOpType::Sin,
    UnaryOpType::Cos,
    UnaryOpType::Abs,
    UnaryOpType::AbsInt32,
    UnaryOpType::Sign,
    UnaryOpType::Square,
    UnaryOpType::Eqz,
    UnaryOpType::Nez,
    UnaryOpType::Gtz,
    UnaryOpType::Ltz,
    UnaryOpType::Gez,
    UnaryOpType::Lez,
    UnaryOpType::ReluMax,
    UnaryOpType::ReluMin,
    UnaryOpType::Power,
    UnaryOpType::LeakyRelu,
    UnaryOpType::Elu,
    UnaryOpType::Exp2,
    UnaryOpType::Heaviside,
    UnaryOpType::Expm1,
    UnaryOpType::Signbit,
    UnaryOpType::Asin,
    UnaryOpType::Acos,
    UnaryOpType::Rsqrt,
    UnaryOpType::Relu6,
    UnaryOpType::Atan,
    UnaryOpType::Erf,
    UnaryOpType::Erfc,
    UnaryOpType::Isinf,
    UnaryOpType::Isposinf,
    UnaryOpType::Isneginf,
    UnaryOpType::Isnan,
    UnaryOpType::LogicalNotUnary,
    UnaryOpType::Isfinite,
    UnaryOpType::Erfinv,
    UnaryOpType::I0,
    UnaryOpType::I1,
    UnaryOpType::Tan,
    UnaryOpType::Rsub,
    UnaryOpType::Rdiv,
    UnaryOpType::Silu,
    UnaryOpType::Softplus,
    UnaryOpType::Identity,
    UnaryOpType::Neg,
    UnaryOpType::AddUnarySfpu,
    UnaryOpType::SubUnarySfpu,
    UnaryOpType::MulUnarySfpu,
    UnaryOpType::DivUnarySfpu,
    UnaryOpType::IdentityUint32,
    UnaryOpType::UnaryNe,
    UnaryOpType::UnaryGt,
    UnaryOpType::UnaryLt,
    UnaryOpType::TiledProd,
    UnaryOpType::Typecast,
    UnaryOpType::BitwiseXor,
    UnaryOpType::BitwiseNot,
    UnaryOpType::BitwiseAnd,
    UnaryOpType::BitwiseOr,
    UnaryOpType::RightShift,
    UnaryOpType::Floor,
    UnaryOpType::Ceil,
    UnaryOpType::Round,
    UnaryOpType::LeftShift,
    UnaryOpType::Remainder,
    UnaryOpType::Fmod,
    UnaryOpType::Dropout,
    UnaryOpType::Fill,
    UnaryOpType::PreluSfpu,
    UnaryOpType::ZeroPoint
  };
  return values;
}
 
inline const char * const *EnumNamesUnaryOpType() {
  static const char * const names[80] = {
    "Exp",
    "Recip",
    "Gelu",
    "Relu",
    "Sqrt",
    "Sigmoid",
    "Log",
    "Tanh",
    "Log2",
    "Log10",
    "Sin",
    "Cos",
    "Abs",
    "AbsInt32",
    "Sign",
    "Square",
    "Eqz",
    "Nez",
    "Gtz",
    "Ltz",
    "Gez",
    "Lez",
    "ReluMax",
    "ReluMin",
    "Power",
    "LeakyRelu",
    "Elu",
    "Exp2",
    "Heaviside",
    "Expm1",
    "Signbit",
    "Asin",
    "Acos",
    "Rsqrt",
    "Relu6",
    "Atan",
    "Erf",
    "Erfc",
    "Isinf",
    "Isposinf",
    "Isneginf",
    "Isnan",
    "LogicalNotUnary",
    "Isfinite",
    "Erfinv",
    "I0",
    "I1",
    "Tan",
    "Rsub",
    "Rdiv",
    "Silu",
    "Softplus",
    "Identity",
    "Neg",
    "AddUnarySfpu",
    "SubUnarySfpu",
    "MulUnarySfpu",
    "DivUnarySfpu",
    "IdentityUint32",
    "UnaryNe",
    "UnaryGt",
    "UnaryLt",
    "TiledProd",
    "Typecast",
    "BitwiseXor",
    "BitwiseNot",
    "BitwiseAnd",
    "BitwiseOr",
    "RightShift",
    "Floor",
    "Ceil",
    "Round",
    "LeftShift",
    "Remainder",
    "Fmod",
    "Dropout",
    "Fill",
    "PreluSfpu",
    "ZeroPoint",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameUnaryOpType(UnaryOpType e) {
  if (::flatbuffers::IsOutRange(e, UnaryOpType::Exp, UnaryOpType::ZeroPoint)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesUnaryOpType()[index];
}
 
struct EltwiseOpWithFloatParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseOpWithFloatParamsBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseOpWithFloatParams";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PARAMETER = 4
  };
  float parameter() const {
    return GetField<float>(VT_PARAMETER, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_PARAMETER, 4) &&
           verifier.EndTable();
  }
};
 
struct EltwiseOpWithFloatParamsBuilder {
  typedef EltwiseOpWithFloatParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_parameter(float parameter) {
    fbb_.AddElement<float>(EltwiseOpWithFloatParams::VT_PARAMETER, parameter, 0.0f);
  }
  explicit EltwiseOpWithFloatParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseOpWithFloatParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseOpWithFloatParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseOpWithFloatParams> CreateEltwiseOpWithFloatParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float parameter = 0.0f) {
  EltwiseOpWithFloatParamsBuilder builder_(_fbb);
  builder_.add_parameter(parameter);
  return builder_.Finish();
}
 
struct EltwiseOpWithFloatParams::Traits {
  using type = EltwiseOpWithFloatParams;
  static auto constexpr Create = CreateEltwiseOpWithFloatParams;
};
 
struct EltwiseBinaryOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseBinaryOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseBinaryOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_LHS = 6,
    VT_RHS = 8,
    VT_OUTPUT_DTYPE = 10,
    VT_MEMORY_CONFIG = 12,
    VT_OUT = 14
  };
  tt::target::ttnn::EltwiseBinaryOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseBinaryOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::ttnn::TensorRef *lhs() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_LHS);
  }
  const tt::target::ttnn::TensorRef *rhs() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_RHS);
  }
  ::flatbuffers::Optional<tt::target::DataType> output_dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_OUTPUT_DTYPE);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_LHS) &&
           verifier.VerifyTable(lhs()) &&
           VerifyOffset(verifier, VT_RHS) &&
           verifier.VerifyTable(rhs()) &&
           VerifyField<uint16_t>(verifier, VT_OUTPUT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EltwiseBinaryOpBuilder {
  typedef EltwiseBinaryOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseBinaryOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseBinaryOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_lhs(::flatbuffers::Offset<tt::target::ttnn::TensorRef> lhs) {
    fbb_.AddOffset(EltwiseBinaryOp::VT_LHS, lhs);
  }
  void add_rhs(::flatbuffers::Offset<tt::target::ttnn::TensorRef> rhs) {
    fbb_.AddOffset(EltwiseBinaryOp::VT_RHS, rhs);
  }
  void add_output_dtype(tt::target::DataType output_dtype) {
    fbb_.AddElement<uint16_t>(EltwiseBinaryOp::VT_OUTPUT_DTYPE, static_cast<uint16_t>(output_dtype));
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseBinaryOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseBinaryOp::VT_OUT, out);
  }
  explicit EltwiseBinaryOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseBinaryOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseBinaryOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseBinaryOp> CreateEltwiseBinaryOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseBinaryOpType type = tt::target::ttnn::EltwiseBinaryOpType::Add,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> lhs = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> rhs = 0,
    ::flatbuffers::Optional<tt::target::DataType> output_dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EltwiseBinaryOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_rhs(rhs);
  builder_.add_lhs(lhs);
  builder_.add_type(type);
  if(output_dtype) { builder_.add_output_dtype(*output_dtype); }
  return builder_.Finish();
}
 
struct EltwiseBinaryOp::Traits {
  using type = EltwiseBinaryOp;
  static auto constexpr Create = CreateEltwiseBinaryOp;
};
 
struct EltwiseBinaryCompositeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseBinaryCompositeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseBinaryCompositeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_LHS = 6,
    VT_RHS = 8,
    VT_MEMORY_CONFIG = 10,
    VT_OUT = 12
  };
  tt::target::ttnn::EltwiseBinaryCompositeOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseBinaryCompositeOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::ttnn::TensorRef *lhs() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_LHS);
  }
  const tt::target::ttnn::TensorRef *rhs() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_RHS);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_LHS) &&
           verifier.VerifyTable(lhs()) &&
           VerifyOffset(verifier, VT_RHS) &&
           verifier.VerifyTable(rhs()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EltwiseBinaryCompositeOpBuilder {
  typedef EltwiseBinaryCompositeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseBinaryCompositeOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseBinaryCompositeOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_lhs(::flatbuffers::Offset<tt::target::ttnn::TensorRef> lhs) {
    fbb_.AddOffset(EltwiseBinaryCompositeOp::VT_LHS, lhs);
  }
  void add_rhs(::flatbuffers::Offset<tt::target::ttnn::TensorRef> rhs) {
    fbb_.AddOffset(EltwiseBinaryCompositeOp::VT_RHS, rhs);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseBinaryCompositeOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseBinaryCompositeOp::VT_OUT, out);
  }
  explicit EltwiseBinaryCompositeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseBinaryCompositeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseBinaryCompositeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseBinaryCompositeOp> CreateEltwiseBinaryCompositeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseBinaryCompositeOpType type = tt::target::ttnn::EltwiseBinaryCompositeOpType::Maximum,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> lhs = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> rhs = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EltwiseBinaryCompositeOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_rhs(rhs);
  builder_.add_lhs(lhs);
  builder_.add_type(type);
  return builder_.Finish();
}
 
struct EltwiseBinaryCompositeOp::Traits {
  using type = EltwiseBinaryCompositeOp;
  static auto constexpr Create = CreateEltwiseBinaryCompositeOp;
};
 
struct PerTensorScale FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PerTensorScaleBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PerTensorScale";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCALE = 4
  };
  float scale() const {
    return GetField<float>(VT_SCALE, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_SCALE, 4) &&
           verifier.EndTable();
  }
};
 
struct PerTensorScaleBuilder {
  typedef PerTensorScale Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_scale(float scale) {
    fbb_.AddElement<float>(PerTensorScale::VT_SCALE, scale, 0.0f);
  }
  explicit PerTensorScaleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PerTensorScale> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PerTensorScale>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PerTensorScale> CreatePerTensorScale(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float scale = 0.0f) {
  PerTensorScaleBuilder builder_(_fbb);
  builder_.add_scale(scale);
  return builder_.Finish();
}
 
struct PerTensorScale::Traits {
  using type = PerTensorScale;
  static auto constexpr Create = CreatePerTensorScale;
};
 
struct PerAxisScale FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PerAxisScaleBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PerAxisScale";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCALE = 4
  };
  const tt::target::ttnn::TensorRef *scale() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_SCALE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SCALE) &&
           verifier.VerifyTable(scale()) &&
           verifier.EndTable();
  }
};
 
struct PerAxisScaleBuilder {
  typedef PerAxisScale Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_scale(::flatbuffers::Offset<tt::target::ttnn::TensorRef> scale) {
    fbb_.AddOffset(PerAxisScale::VT_SCALE, scale);
  }
  explicit PerAxisScaleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PerAxisScale> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PerAxisScale>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PerAxisScale> CreatePerAxisScale(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> scale = 0) {
  PerAxisScaleBuilder builder_(_fbb);
  builder_.add_scale(scale);
  return builder_.Finish();
}
 
struct PerAxisScale::Traits {
  using type = PerAxisScale;
  static auto constexpr Create = CreatePerAxisScale;
};
 
struct PerTensorZeroPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PerTensorZeroPointBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PerTensorZeroPoint";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ZERO_POINT = 4
  };
  int32_t zero_point() const {
    return GetField<int32_t>(VT_ZERO_POINT, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_ZERO_POINT, 4) &&
           verifier.EndTable();
  }
};
 
struct PerTensorZeroPointBuilder {
  typedef PerTensorZeroPoint Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_zero_point(int32_t zero_point) {
    fbb_.AddElement<int32_t>(PerTensorZeroPoint::VT_ZERO_POINT, zero_point, 0);
  }
  explicit PerTensorZeroPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PerTensorZeroPoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PerTensorZeroPoint>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PerTensorZeroPoint> CreatePerTensorZeroPoint(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t zero_point = 0) {
  PerTensorZeroPointBuilder builder_(_fbb);
  builder_.add_zero_point(zero_point);
  return builder_.Finish();
}
 
struct PerTensorZeroPoint::Traits {
  using type = PerTensorZeroPoint;
  static auto constexpr Create = CreatePerTensorZeroPoint;
};
 
struct PerAxisZeroPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PerAxisZeroPointBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.PerAxisZeroPoint";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ZERO_POINT = 4
  };
  const tt::target::ttnn::TensorRef *zero_point() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_ZERO_POINT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ZERO_POINT) &&
           verifier.VerifyTable(zero_point()) &&
           verifier.EndTable();
  }
};
 
struct PerAxisZeroPointBuilder {
  typedef PerAxisZeroPoint Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_zero_point(::flatbuffers::Offset<tt::target::ttnn::TensorRef> zero_point) {
    fbb_.AddOffset(PerAxisZeroPoint::VT_ZERO_POINT, zero_point);
  }
  explicit PerAxisZeroPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PerAxisZeroPoint> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PerAxisZeroPoint>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<PerAxisZeroPoint> CreatePerAxisZeroPoint(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> zero_point = 0) {
  PerAxisZeroPointBuilder builder_(_fbb);
  builder_.add_zero_point(zero_point);
  return builder_.Finish();
}
 
struct PerAxisZeroPoint::Traits {
  using type = PerAxisZeroPoint;
  static auto constexpr Create = CreatePerAxisZeroPoint;
};
 
struct QuantizeDequantizeOpParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef QuantizeDequantizeOpParamsBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.QuantizeDequantizeOpParams";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCALE_TYPE = 4,
    VT_SCALE = 6,
    VT_ZERO_POINT_TYPE = 8,
    VT_ZERO_POINT = 10
  };
  tt::target::ttnn::QuantizationScale scale_type() const {
    return static_cast<tt::target::ttnn::QuantizationScale>(GetField<uint8_t>(VT_SCALE_TYPE, 0));
  }
  const void *scale() const {
    return GetPointer<const void *>(VT_SCALE);
  }
  template<typename T> const T *scale_as() const;
  const tt::target::ttnn::PerTensorScale *scale_as_PerTensorScale() const {
    return scale_type() == tt::target::ttnn::QuantizationScale::PerTensorScale ? static_cast<const tt::target::ttnn::PerTensorScale *>(scale()) : nullptr;
  }
  const tt::target::ttnn::PerAxisScale *scale_as_PerAxisScale() const {
    return scale_type() == tt::target::ttnn::QuantizationScale::PerAxisScale ? static_cast<const tt::target::ttnn::PerAxisScale *>(scale()) : nullptr;
  }
  tt::target::ttnn::QuantizationZeroPoint zero_point_type() const {
    return static_cast<tt::target::ttnn::QuantizationZeroPoint>(GetField<uint8_t>(VT_ZERO_POINT_TYPE, 0));
  }
  const void *zero_point() const {
    return GetPointer<const void *>(VT_ZERO_POINT);
  }
  template<typename T> const T *zero_point_as() const;
  const tt::target::ttnn::PerTensorZeroPoint *zero_point_as_PerTensorZeroPoint() const {
    return zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerTensorZeroPoint ? static_cast<const tt::target::ttnn::PerTensorZeroPoint *>(zero_point()) : nullptr;
  }
  const tt::target::ttnn::PerAxisZeroPoint *zero_point_as_PerAxisZeroPoint() const {
    return zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerAxisZeroPoint ? static_cast<const tt::target::ttnn::PerAxisZeroPoint *>(zero_point()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SCALE_TYPE, 1) &&
           VerifyOffset(verifier, VT_SCALE) &&
           VerifyQuantizationScale(verifier, scale(), scale_type()) &&
           VerifyField<uint8_t>(verifier, VT_ZERO_POINT_TYPE, 1) &&
           VerifyOffset(verifier, VT_ZERO_POINT) &&
           VerifyQuantizationZeroPoint(verifier, zero_point(), zero_point_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::PerTensorScale *QuantizeDequantizeOpParams::scale_as<tt::target::ttnn::PerTensorScale>() const {
  return scale_as_PerTensorScale();
}
 
template<> inline const tt::target::ttnn::PerAxisScale *QuantizeDequantizeOpParams::scale_as<tt::target::ttnn::PerAxisScale>() const {
  return scale_as_PerAxisScale();
}
 
template<> inline const tt::target::ttnn::PerTensorZeroPoint *QuantizeDequantizeOpParams::zero_point_as<tt::target::ttnn::PerTensorZeroPoint>() const {
  return zero_point_as_PerTensorZeroPoint();
}
 
template<> inline const tt::target::ttnn::PerAxisZeroPoint *QuantizeDequantizeOpParams::zero_point_as<tt::target::ttnn::PerAxisZeroPoint>() const {
  return zero_point_as_PerAxisZeroPoint();
}
 
struct QuantizeDequantizeOpParamsBuilder {
  typedef QuantizeDequantizeOpParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_scale_type(tt::target::ttnn::QuantizationScale scale_type) {
    fbb_.AddElement<uint8_t>(QuantizeDequantizeOpParams::VT_SCALE_TYPE, static_cast<uint8_t>(scale_type), 0);
  }
  void add_scale(::flatbuffers::Offset<void> scale) {
    fbb_.AddOffset(QuantizeDequantizeOpParams::VT_SCALE, scale);
  }
  void add_zero_point_type(tt::target::ttnn::QuantizationZeroPoint zero_point_type) {
    fbb_.AddElement<uint8_t>(QuantizeDequantizeOpParams::VT_ZERO_POINT_TYPE, static_cast<uint8_t>(zero_point_type), 0);
  }
  void add_zero_point(::flatbuffers::Offset<void> zero_point) {
    fbb_.AddOffset(QuantizeDequantizeOpParams::VT_ZERO_POINT, zero_point);
  }
  explicit QuantizeDequantizeOpParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<QuantizeDequantizeOpParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<QuantizeDequantizeOpParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<QuantizeDequantizeOpParams> CreateQuantizeDequantizeOpParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::QuantizationScale scale_type = tt::target::ttnn::QuantizationScale::NONE,
    ::flatbuffers::Offset<void> scale = 0,
    tt::target::ttnn::QuantizationZeroPoint zero_point_type = tt::target::ttnn::QuantizationZeroPoint::NONE,
    ::flatbuffers::Offset<void> zero_point = 0) {
  QuantizeDequantizeOpParamsBuilder builder_(_fbb);
  builder_.add_zero_point(zero_point);
  builder_.add_scale(scale);
  builder_.add_zero_point_type(zero_point_type);
  builder_.add_scale_type(scale_type);
  return builder_.Finish();
}
 
struct QuantizeDequantizeOpParams::Traits {
  using type = QuantizeDequantizeOpParams;
  static auto constexpr Create = CreateQuantizeDequantizeOpParams;
};
 
struct RequantizeOpParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RequantizeOpParamsBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.RequantizeOpParams";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN_SCALE_TYPE = 4,
    VT_IN_SCALE = 6,
    VT_IN_ZERO_POINT_TYPE = 8,
    VT_IN_ZERO_POINT = 10,
    VT_OUT_SCALE_TYPE = 12,
    VT_OUT_SCALE = 14,
    VT_OUT_ZERO_POINT_TYPE = 16,
    VT_OUT_ZERO_POINT = 18
  };
  tt::target::ttnn::QuantizationScale in_scale_type() const {
    return static_cast<tt::target::ttnn::QuantizationScale>(GetField<uint8_t>(VT_IN_SCALE_TYPE, 0));
  }
  const void *in_scale() const {
    return GetPointer<const void *>(VT_IN_SCALE);
  }
  template<typename T> const T *in_scale_as() const;
  const tt::target::ttnn::PerTensorScale *in_scale_as_PerTensorScale() const {
    return in_scale_type() == tt::target::ttnn::QuantizationScale::PerTensorScale ? static_cast<const tt::target::ttnn::PerTensorScale *>(in_scale()) : nullptr;
  }
  const tt::target::ttnn::PerAxisScale *in_scale_as_PerAxisScale() const {
    return in_scale_type() == tt::target::ttnn::QuantizationScale::PerAxisScale ? static_cast<const tt::target::ttnn::PerAxisScale *>(in_scale()) : nullptr;
  }
  tt::target::ttnn::QuantizationZeroPoint in_zero_point_type() const {
    return static_cast<tt::target::ttnn::QuantizationZeroPoint>(GetField<uint8_t>(VT_IN_ZERO_POINT_TYPE, 0));
  }
  const void *in_zero_point() const {
    return GetPointer<const void *>(VT_IN_ZERO_POINT);
  }
  template<typename T> const T *in_zero_point_as() const;
  const tt::target::ttnn::PerTensorZeroPoint *in_zero_point_as_PerTensorZeroPoint() const {
    return in_zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerTensorZeroPoint ? static_cast<const tt::target::ttnn::PerTensorZeroPoint *>(in_zero_point()) : nullptr;
  }
  const tt::target::ttnn::PerAxisZeroPoint *in_zero_point_as_PerAxisZeroPoint() const {
    return in_zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerAxisZeroPoint ? static_cast<const tt::target::ttnn::PerAxisZeroPoint *>(in_zero_point()) : nullptr;
  }
  tt::target::ttnn::QuantizationScale out_scale_type() const {
    return static_cast<tt::target::ttnn::QuantizationScale>(GetField<uint8_t>(VT_OUT_SCALE_TYPE, 0));
  }
  const void *out_scale() const {
    return GetPointer<const void *>(VT_OUT_SCALE);
  }
  template<typename T> const T *out_scale_as() const;
  const tt::target::ttnn::PerTensorScale *out_scale_as_PerTensorScale() const {
    return out_scale_type() == tt::target::ttnn::QuantizationScale::PerTensorScale ? static_cast<const tt::target::ttnn::PerTensorScale *>(out_scale()) : nullptr;
  }
  const tt::target::ttnn::PerAxisScale *out_scale_as_PerAxisScale() const {
    return out_scale_type() == tt::target::ttnn::QuantizationScale::PerAxisScale ? static_cast<const tt::target::ttnn::PerAxisScale *>(out_scale()) : nullptr;
  }
  tt::target::ttnn::QuantizationZeroPoint out_zero_point_type() const {
    return static_cast<tt::target::ttnn::QuantizationZeroPoint>(GetField<uint8_t>(VT_OUT_ZERO_POINT_TYPE, 0));
  }
  const void *out_zero_point() const {
    return GetPointer<const void *>(VT_OUT_ZERO_POINT);
  }
  template<typename T> const T *out_zero_point_as() const;
  const tt::target::ttnn::PerTensorZeroPoint *out_zero_point_as_PerTensorZeroPoint() const {
    return out_zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerTensorZeroPoint ? static_cast<const tt::target::ttnn::PerTensorZeroPoint *>(out_zero_point()) : nullptr;
  }
  const tt::target::ttnn::PerAxisZeroPoint *out_zero_point_as_PerAxisZeroPoint() const {
    return out_zero_point_type() == tt::target::ttnn::QuantizationZeroPoint::PerAxisZeroPoint ? static_cast<const tt::target::ttnn::PerAxisZeroPoint *>(out_zero_point()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_IN_SCALE_TYPE, 1) &&
           VerifyOffset(verifier, VT_IN_SCALE) &&
           VerifyQuantizationScale(verifier, in_scale(), in_scale_type()) &&
           VerifyField<uint8_t>(verifier, VT_IN_ZERO_POINT_TYPE, 1) &&
           VerifyOffset(verifier, VT_IN_ZERO_POINT) &&
           VerifyQuantizationZeroPoint(verifier, in_zero_point(), in_zero_point_type()) &&
           VerifyField<uint8_t>(verifier, VT_OUT_SCALE_TYPE, 1) &&
           VerifyOffset(verifier, VT_OUT_SCALE) &&
           VerifyQuantizationScale(verifier, out_scale(), out_scale_type()) &&
           VerifyField<uint8_t>(verifier, VT_OUT_ZERO_POINT_TYPE, 1) &&
           VerifyOffset(verifier, VT_OUT_ZERO_POINT) &&
           VerifyQuantizationZeroPoint(verifier, out_zero_point(), out_zero_point_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::PerTensorScale *RequantizeOpParams::in_scale_as<tt::target::ttnn::PerTensorScale>() const {
  return in_scale_as_PerTensorScale();
}
 
template<> inline const tt::target::ttnn::PerAxisScale *RequantizeOpParams::in_scale_as<tt::target::ttnn::PerAxisScale>() const {
  return in_scale_as_PerAxisScale();
}
 
template<> inline const tt::target::ttnn::PerTensorZeroPoint *RequantizeOpParams::in_zero_point_as<tt::target::ttnn::PerTensorZeroPoint>() const {
  return in_zero_point_as_PerTensorZeroPoint();
}
 
template<> inline const tt::target::ttnn::PerAxisZeroPoint *RequantizeOpParams::in_zero_point_as<tt::target::ttnn::PerAxisZeroPoint>() const {
  return in_zero_point_as_PerAxisZeroPoint();
}
 
template<> inline const tt::target::ttnn::PerTensorScale *RequantizeOpParams::out_scale_as<tt::target::ttnn::PerTensorScale>() const {
  return out_scale_as_PerTensorScale();
}
 
template<> inline const tt::target::ttnn::PerAxisScale *RequantizeOpParams::out_scale_as<tt::target::ttnn::PerAxisScale>() const {
  return out_scale_as_PerAxisScale();
}
 
template<> inline const tt::target::ttnn::PerTensorZeroPoint *RequantizeOpParams::out_zero_point_as<tt::target::ttnn::PerTensorZeroPoint>() const {
  return out_zero_point_as_PerTensorZeroPoint();
}
 
template<> inline const tt::target::ttnn::PerAxisZeroPoint *RequantizeOpParams::out_zero_point_as<tt::target::ttnn::PerAxisZeroPoint>() const {
  return out_zero_point_as_PerAxisZeroPoint();
}
 
struct RequantizeOpParamsBuilder {
  typedef RequantizeOpParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in_scale_type(tt::target::ttnn::QuantizationScale in_scale_type) {
    fbb_.AddElement<uint8_t>(RequantizeOpParams::VT_IN_SCALE_TYPE, static_cast<uint8_t>(in_scale_type), 0);
  }
  void add_in_scale(::flatbuffers::Offset<void> in_scale) {
    fbb_.AddOffset(RequantizeOpParams::VT_IN_SCALE, in_scale);
  }
  void add_in_zero_point_type(tt::target::ttnn::QuantizationZeroPoint in_zero_point_type) {
    fbb_.AddElement<uint8_t>(RequantizeOpParams::VT_IN_ZERO_POINT_TYPE, static_cast<uint8_t>(in_zero_point_type), 0);
  }
  void add_in_zero_point(::flatbuffers::Offset<void> in_zero_point) {
    fbb_.AddOffset(RequantizeOpParams::VT_IN_ZERO_POINT, in_zero_point);
  }
  void add_out_scale_type(tt::target::ttnn::QuantizationScale out_scale_type) {
    fbb_.AddElement<uint8_t>(RequantizeOpParams::VT_OUT_SCALE_TYPE, static_cast<uint8_t>(out_scale_type), 0);
  }
  void add_out_scale(::flatbuffers::Offset<void> out_scale) {
    fbb_.AddOffset(RequantizeOpParams::VT_OUT_SCALE, out_scale);
  }
  void add_out_zero_point_type(tt::target::ttnn::QuantizationZeroPoint out_zero_point_type) {
    fbb_.AddElement<uint8_t>(RequantizeOpParams::VT_OUT_ZERO_POINT_TYPE, static_cast<uint8_t>(out_zero_point_type), 0);
  }
  void add_out_zero_point(::flatbuffers::Offset<void> out_zero_point) {
    fbb_.AddOffset(RequantizeOpParams::VT_OUT_ZERO_POINT, out_zero_point);
  }
  explicit RequantizeOpParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<RequantizeOpParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<RequantizeOpParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<RequantizeOpParams> CreateRequantizeOpParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::QuantizationScale in_scale_type = tt::target::ttnn::QuantizationScale::NONE,
    ::flatbuffers::Offset<void> in_scale = 0,
    tt::target::ttnn::QuantizationZeroPoint in_zero_point_type = tt::target::ttnn::QuantizationZeroPoint::NONE,
    ::flatbuffers::Offset<void> in_zero_point = 0,
    tt::target::ttnn::QuantizationScale out_scale_type = tt::target::ttnn::QuantizationScale::NONE,
    ::flatbuffers::Offset<void> out_scale = 0,
    tt::target::ttnn::QuantizationZeroPoint out_zero_point_type = tt::target::ttnn::QuantizationZeroPoint::NONE,
    ::flatbuffers::Offset<void> out_zero_point = 0) {
  RequantizeOpParamsBuilder builder_(_fbb);
  builder_.add_out_zero_point(out_zero_point);
  builder_.add_out_scale(out_scale);
  builder_.add_in_zero_point(in_zero_point);
  builder_.add_in_scale(in_scale);
  builder_.add_out_zero_point_type(out_zero_point_type);
  builder_.add_out_scale_type(out_scale_type);
  builder_.add_in_zero_point_type(in_zero_point_type);
  builder_.add_in_scale_type(in_scale_type);
  return builder_.Finish();
}
 
struct RequantizeOpParams::Traits {
  using type = RequantizeOpParams;
  static auto constexpr Create = CreateRequantizeOpParams;
};
 
struct EltwiseQuantizationOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseQuantizationOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseQuantizationOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_IN = 6,
    VT_AXIS = 8,
    VT_OUTPUT_DTYPE = 10,
    VT_MEMORY_CONFIG = 12,
    VT_OUT = 14,
    VT_PARAMS_TYPE = 16,
    VT_PARAMS = 18
  };
  tt::target::ttnn::EltwiseQuantizationOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseQuantizationOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  ::flatbuffers::Optional<int32_t> axis() const {
    return GetOptional<int32_t, int32_t>(VT_AXIS);
  }
  ::flatbuffers::Optional<tt::target::DataType> output_dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_OUTPUT_DTYPE);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  tt::target::ttnn::EltwiseQuantizationOpParams params_type() const {
    return static_cast<tt::target::ttnn::EltwiseQuantizationOpParams>(GetField<uint8_t>(VT_PARAMS_TYPE, 0));
  }
  const void *params() const {
    return GetPointer<const void *>(VT_PARAMS);
  }
  template<typename T> const T *params_as() const;
  const tt::target::ttnn::QuantizeDequantizeOpParams *params_as_QuantizeDequantizeOpParams() const {
    return params_type() == tt::target::ttnn::EltwiseQuantizationOpParams::QuantizeDequantizeOpParams ? static_cast<const tt::target::ttnn::QuantizeDequantizeOpParams *>(params()) : nullptr;
  }
  const tt::target::ttnn::RequantizeOpParams *params_as_RequantizeOpParams() const {
    return params_type() == tt::target::ttnn::EltwiseQuantizationOpParams::RequantizeOpParams ? static_cast<const tt::target::ttnn::RequantizeOpParams *>(params()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
           VerifyField<uint16_t>(verifier, VT_OUTPUT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_PARAMS_TYPE, 1) &&
           VerifyOffset(verifier, VT_PARAMS) &&
           VerifyEltwiseQuantizationOpParams(verifier, params(), params_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::QuantizeDequantizeOpParams *EltwiseQuantizationOp::params_as<tt::target::ttnn::QuantizeDequantizeOpParams>() const {
  return params_as_QuantizeDequantizeOpParams();
}
 
template<> inline const tt::target::ttnn::RequantizeOpParams *EltwiseQuantizationOp::params_as<tt::target::ttnn::RequantizeOpParams>() const {
  return params_as_RequantizeOpParams();
}
 
struct EltwiseQuantizationOpBuilder {
  typedef EltwiseQuantizationOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseQuantizationOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseQuantizationOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(EltwiseQuantizationOp::VT_IN, in);
  }
  void add_axis(int32_t axis) {
    fbb_.AddElement<int32_t>(EltwiseQuantizationOp::VT_AXIS, axis);
  }
  void add_output_dtype(tt::target::DataType output_dtype) {
    fbb_.AddElement<uint16_t>(EltwiseQuantizationOp::VT_OUTPUT_DTYPE, static_cast<uint16_t>(output_dtype));
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseQuantizationOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseQuantizationOp::VT_OUT, out);
  }
  void add_params_type(tt::target::ttnn::EltwiseQuantizationOpParams params_type) {
    fbb_.AddElement<uint8_t>(EltwiseQuantizationOp::VT_PARAMS_TYPE, static_cast<uint8_t>(params_type), 0);
  }
  void add_params(::flatbuffers::Offset<void> params) {
    fbb_.AddOffset(EltwiseQuantizationOp::VT_PARAMS, params);
  }
  explicit EltwiseQuantizationOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseQuantizationOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseQuantizationOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseQuantizationOp> CreateEltwiseQuantizationOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseQuantizationOpType type = tt::target::ttnn::EltwiseQuantizationOpType::Quantize,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Optional<int32_t> axis = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<tt::target::DataType> output_dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    tt::target::ttnn::EltwiseQuantizationOpParams params_type = tt::target::ttnn::EltwiseQuantizationOpParams::NONE,
    ::flatbuffers::Offset<void> params = 0) {
  EltwiseQuantizationOpBuilder builder_(_fbb);
  builder_.add_params(params);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  if(axis) { builder_.add_axis(*axis); }
  builder_.add_in(in);
  builder_.add_type(type);
  if(output_dtype) { builder_.add_output_dtype(*output_dtype); }
  builder_.add_params_type(params_type);
  return builder_.Finish();
}
 
struct EltwiseQuantizationOp::Traits {
  using type = EltwiseQuantizationOp;
  static auto constexpr Create = CreateEltwiseQuantizationOp;
};
 
struct EltwiseTernaryWhereOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseTernaryWhereOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseTernaryWhereOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FIRST = 4,
    VT_SECOND = 6,
    VT_THIRD = 8,
    VT_MEMORY_CONFIG = 10,
    VT_OUT = 12
  };
  const tt::target::ttnn::TensorRef *first() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_FIRST);
  }
  const tt::target::ttnn::TensorRef *second() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_SECOND);
  }
  const tt::target::ttnn::TensorRef *third() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_THIRD);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  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_FIRST) &&
           verifier.VerifyTable(first()) &&
           VerifyOffset(verifier, VT_SECOND) &&
           verifier.VerifyTable(second()) &&
           VerifyOffset(verifier, VT_THIRD) &&
           verifier.VerifyTable(third()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EltwiseTernaryWhereOpBuilder {
  typedef EltwiseTernaryWhereOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_first(::flatbuffers::Offset<tt::target::ttnn::TensorRef> first) {
    fbb_.AddOffset(EltwiseTernaryWhereOp::VT_FIRST, first);
  }
  void add_second(::flatbuffers::Offset<tt::target::ttnn::TensorRef> second) {
    fbb_.AddOffset(EltwiseTernaryWhereOp::VT_SECOND, second);
  }
  void add_third(::flatbuffers::Offset<tt::target::ttnn::TensorRef> third) {
    fbb_.AddOffset(EltwiseTernaryWhereOp::VT_THIRD, third);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseTernaryWhereOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseTernaryWhereOp::VT_OUT, out);
  }
  explicit EltwiseTernaryWhereOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseTernaryWhereOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseTernaryWhereOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseTernaryWhereOp> CreateEltwiseTernaryWhereOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> first = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> second = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> third = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EltwiseTernaryWhereOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_third(third);
  builder_.add_second(second);
  builder_.add_first(first);
  return builder_.Finish();
}
 
struct EltwiseTernaryWhereOp::Traits {
  using type = EltwiseTernaryWhereOp;
  static auto constexpr Create = CreateEltwiseTernaryWhereOp;
};
 
struct EltwiseUnaryOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseUnaryOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseUnaryOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_IN = 6,
    VT_MEMORY_CONFIG = 8,
    VT_OUT = 10,
    VT_PARAMS_TYPE = 12,
    VT_PARAMS = 14
  };
  tt::target::ttnn::EltwiseUnaryOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseUnaryOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  tt::target::ttnn::EltwiseUnaryOpParams params_type() const {
    return static_cast<tt::target::ttnn::EltwiseUnaryOpParams>(GetField<uint8_t>(VT_PARAMS_TYPE, 0));
  }
  const void *params() const {
    return GetPointer<const void *>(VT_PARAMS);
  }
  template<typename T> const T *params_as() const;
  const tt::target::ttnn::EltwiseOpWithFloatParams *params_as_EltwiseOpWithFloatParams() const {
    return params_type() == tt::target::ttnn::EltwiseUnaryOpParams::EltwiseOpWithFloatParams ? static_cast<const tt::target::ttnn::EltwiseOpWithFloatParams *>(params()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_PARAMS_TYPE, 1) &&
           VerifyOffset(verifier, VT_PARAMS) &&
           VerifyEltwiseUnaryOpParams(verifier, params(), params_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::EltwiseOpWithFloatParams *EltwiseUnaryOp::params_as<tt::target::ttnn::EltwiseOpWithFloatParams>() const {
  return params_as_EltwiseOpWithFloatParams();
}
 
struct EltwiseUnaryOpBuilder {
  typedef EltwiseUnaryOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseUnaryOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseUnaryOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(EltwiseUnaryOp::VT_IN, in);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseUnaryOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseUnaryOp::VT_OUT, out);
  }
  void add_params_type(tt::target::ttnn::EltwiseUnaryOpParams params_type) {
    fbb_.AddElement<uint8_t>(EltwiseUnaryOp::VT_PARAMS_TYPE, static_cast<uint8_t>(params_type), 0);
  }
  void add_params(::flatbuffers::Offset<void> params) {
    fbb_.AddOffset(EltwiseUnaryOp::VT_PARAMS, params);
  }
  explicit EltwiseUnaryOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseUnaryOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseUnaryOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseUnaryOp> CreateEltwiseUnaryOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseUnaryOpType type = tt::target::ttnn::EltwiseUnaryOpType::Abs,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    tt::target::ttnn::EltwiseUnaryOpParams params_type = tt::target::ttnn::EltwiseUnaryOpParams::NONE,
    ::flatbuffers::Offset<void> params = 0) {
  EltwiseUnaryOpBuilder builder_(_fbb);
  builder_.add_params(params);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_in(in);
  builder_.add_type(type);
  builder_.add_params_type(params_type);
  return builder_.Finish();
}
 
struct EltwiseUnaryOp::Traits {
  using type = EltwiseUnaryOp;
  static auto constexpr Create = CreateEltwiseUnaryOp;
};
 
struct ClampScalarOpParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ClampScalarOpParamsBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ClampScalarOpParams";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MIN = 4,
    VT_MAX = 6
  };
  float min() const {
    return GetField<float>(VT_MIN, 0.0f);
  }
  float max() const {
    return GetField<float>(VT_MAX, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_MIN, 4) &&
           VerifyField<float>(verifier, VT_MAX, 4) &&
           verifier.EndTable();
  }
};
 
struct ClampScalarOpParamsBuilder {
  typedef ClampScalarOpParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_min(float min) {
    fbb_.AddElement<float>(ClampScalarOpParams::VT_MIN, min, 0.0f);
  }
  void add_max(float max) {
    fbb_.AddElement<float>(ClampScalarOpParams::VT_MAX, max, 0.0f);
  }
  explicit ClampScalarOpParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ClampScalarOpParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ClampScalarOpParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ClampScalarOpParams> CreateClampScalarOpParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float min = 0.0f,
    float max = 0.0f) {
  ClampScalarOpParamsBuilder builder_(_fbb);
  builder_.add_max(max);
  builder_.add_min(min);
  return builder_.Finish();
}
 
struct ClampScalarOpParams::Traits {
  using type = ClampScalarOpParams;
  static auto constexpr Create = CreateClampScalarOpParams;
};
 
struct ClampTensorOpParams FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ClampTensorOpParamsBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ClampTensorOpParams";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MIN = 4,
    VT_MAX = 6
  };
  const tt::target::ttnn::TensorRef *min() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_MIN);
  }
  const tt::target::ttnn::TensorRef *max() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_MAX);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_MIN) &&
           verifier.VerifyTable(min()) &&
           VerifyOffset(verifier, VT_MAX) &&
           verifier.VerifyTable(max()) &&
           verifier.EndTable();
  }
};
 
struct ClampTensorOpParamsBuilder {
  typedef ClampTensorOpParams Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_min(::flatbuffers::Offset<tt::target::ttnn::TensorRef> min) {
    fbb_.AddOffset(ClampTensorOpParams::VT_MIN, min);
  }
  void add_max(::flatbuffers::Offset<tt::target::ttnn::TensorRef> max) {
    fbb_.AddOffset(ClampTensorOpParams::VT_MAX, max);
  }
  explicit ClampTensorOpParamsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ClampTensorOpParams> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ClampTensorOpParams>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ClampTensorOpParams> CreateClampTensorOpParams(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> min = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> max = 0) {
  ClampTensorOpParamsBuilder builder_(_fbb);
  builder_.add_max(max);
  builder_.add_min(min);
  return builder_.Finish();
}
 
struct ClampTensorOpParams::Traits {
  using type = ClampTensorOpParams;
  static auto constexpr Create = CreateClampTensorOpParams;
};
 
struct EltwiseUnaryCompositeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EltwiseUnaryCompositeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EltwiseUnaryCompositeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_IN = 6,
    VT_MEMORY_CONFIG = 8,
    VT_OUT = 10,
    VT_PARAMS_TYPE = 12,
    VT_PARAMS = 14
  };
  tt::target::ttnn::EltwiseUnaryCompositeOpType type() const {
    return static_cast<tt::target::ttnn::EltwiseUnaryCompositeOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  tt::target::ttnn::EltwiseUnaryCompositeOpParams params_type() const {
    return static_cast<tt::target::ttnn::EltwiseUnaryCompositeOpParams>(GetField<uint8_t>(VT_PARAMS_TYPE, 0));
  }
  const void *params() const {
    return GetPointer<const void *>(VT_PARAMS);
  }
  template<typename T> const T *params_as() const;
  const tt::target::ttnn::ClampScalarOpParams *params_as_ClampScalarOpParams() const {
    return params_type() == tt::target::ttnn::EltwiseUnaryCompositeOpParams::ClampScalarOpParams ? static_cast<const tt::target::ttnn::ClampScalarOpParams *>(params()) : nullptr;
  }
  const tt::target::ttnn::ClampTensorOpParams *params_as_ClampTensorOpParams() const {
    return params_type() == tt::target::ttnn::EltwiseUnaryCompositeOpParams::ClampTensorOpParams ? static_cast<const tt::target::ttnn::ClampTensorOpParams *>(params()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_PARAMS_TYPE, 1) &&
           VerifyOffset(verifier, VT_PARAMS) &&
           VerifyEltwiseUnaryCompositeOpParams(verifier, params(), params_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::ClampScalarOpParams *EltwiseUnaryCompositeOp::params_as<tt::target::ttnn::ClampScalarOpParams>() const {
  return params_as_ClampScalarOpParams();
}
 
template<> inline const tt::target::ttnn::ClampTensorOpParams *EltwiseUnaryCompositeOp::params_as<tt::target::ttnn::ClampTensorOpParams>() const {
  return params_as_ClampTensorOpParams();
}
 
struct EltwiseUnaryCompositeOpBuilder {
  typedef EltwiseUnaryCompositeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::EltwiseUnaryCompositeOpType type) {
    fbb_.AddElement<uint32_t>(EltwiseUnaryCompositeOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(EltwiseUnaryCompositeOp::VT_IN, in);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(EltwiseUnaryCompositeOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EltwiseUnaryCompositeOp::VT_OUT, out);
  }
  void add_params_type(tt::target::ttnn::EltwiseUnaryCompositeOpParams params_type) {
    fbb_.AddElement<uint8_t>(EltwiseUnaryCompositeOp::VT_PARAMS_TYPE, static_cast<uint8_t>(params_type), 0);
  }
  void add_params(::flatbuffers::Offset<void> params) {
    fbb_.AddOffset(EltwiseUnaryCompositeOp::VT_PARAMS, params);
  }
  explicit EltwiseUnaryCompositeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EltwiseUnaryCompositeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EltwiseUnaryCompositeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EltwiseUnaryCompositeOp> CreateEltwiseUnaryCompositeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::EltwiseUnaryCompositeOpType type = tt::target::ttnn::EltwiseUnaryCompositeOpType::Cbrt,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    tt::target::ttnn::EltwiseUnaryCompositeOpParams params_type = tt::target::ttnn::EltwiseUnaryCompositeOpParams::NONE,
    ::flatbuffers::Offset<void> params = 0) {
  EltwiseUnaryCompositeOpBuilder builder_(_fbb);
  builder_.add_params(params);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_in(in);
  builder_.add_type(type);
  builder_.add_params_type(params_type);
  return builder_.Finish();
}
 
struct EltwiseUnaryCompositeOp::Traits {
  using type = EltwiseUnaryCompositeOp;
  static auto constexpr Create = CreateEltwiseUnaryCompositeOp;
};
 
struct UnaryWithParam FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UnaryWithParamBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.UnaryWithParam";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OP_TYPE = 4,
    VT_PARAMS = 6
  };
  tt::target::ttnn::UnaryOpType op_type() const {
    return static_cast<tt::target::ttnn::UnaryOpType>(GetField<uint32_t>(VT_OP_TYPE, 0));
  }
  const ::flatbuffers::Vector<double> *params() const {
    return GetPointer<const ::flatbuffers::Vector<double> *>(VT_PARAMS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_OP_TYPE, 4) &&
           VerifyOffset(verifier, VT_PARAMS) &&
           verifier.VerifyVector(params()) &&
           verifier.EndTable();
  }
};
 
struct UnaryWithParamBuilder {
  typedef UnaryWithParam Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_op_type(tt::target::ttnn::UnaryOpType op_type) {
    fbb_.AddElement<uint32_t>(UnaryWithParam::VT_OP_TYPE, static_cast<uint32_t>(op_type), 0);
  }
  void add_params(::flatbuffers::Offset<::flatbuffers::Vector<double>> params) {
    fbb_.AddOffset(UnaryWithParam::VT_PARAMS, params);
  }
  explicit UnaryWithParamBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UnaryWithParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UnaryWithParam>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<UnaryWithParam> CreateUnaryWithParam(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::UnaryOpType op_type = tt::target::ttnn::UnaryOpType::Exp,
    ::flatbuffers::Offset<::flatbuffers::Vector<double>> params = 0) {
  UnaryWithParamBuilder builder_(_fbb);
  builder_.add_params(params);
  builder_.add_op_type(op_type);
  return builder_.Finish();
}
 
struct UnaryWithParam::Traits {
  using type = UnaryWithParam;
  static auto constexpr Create = CreateUnaryWithParam;
};
 
inline ::flatbuffers::Offset<UnaryWithParam> CreateUnaryWithParamDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::UnaryOpType op_type = tt::target::ttnn::UnaryOpType::Exp,
    const std::vector<double> *params = nullptr) {
  auto params__ = params ? _fbb.CreateVector<double>(*params) : 0;
  return tt::target::ttnn::CreateUnaryWithParam(
      _fbb,
      op_type,
      params__);
}
 
inline bool VerifyQuantizationScale(::flatbuffers::Verifier &verifier, const void *obj, QuantizationScale type) {
  switch (type) {
    case QuantizationScale::NONE: {
      return true;
    }
    case QuantizationScale::PerTensorScale: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PerTensorScale *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case QuantizationScale::PerAxisScale: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PerAxisScale *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyQuantizationScaleVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationScale> *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 (!VerifyQuantizationScale(
        verifier,  values->Get(i), types->GetEnum<QuantizationScale>(i))) {
      return false;
    }
  }
  return true;
}
 
inline bool VerifyQuantizationZeroPoint(::flatbuffers::Verifier &verifier, const void *obj, QuantizationZeroPoint type) {
  switch (type) {
    case QuantizationZeroPoint::NONE: {
      return true;
    }
    case QuantizationZeroPoint::PerTensorZeroPoint: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PerTensorZeroPoint *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case QuantizationZeroPoint::PerAxisZeroPoint: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::PerAxisZeroPoint *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyQuantizationZeroPointVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<QuantizationZeroPoint> *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 (!VerifyQuantizationZeroPoint(
        verifier,  values->Get(i), types->GetEnum<QuantizationZeroPoint>(i))) {
      return false;
    }
  }
  return true;
}
 
inline bool VerifyEltwiseQuantizationOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseQuantizationOpParams type) {
  switch (type) {
    case EltwiseQuantizationOpParams::NONE: {
      return true;
    }
    case EltwiseQuantizationOpParams::QuantizeDequantizeOpParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::QuantizeDequantizeOpParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case EltwiseQuantizationOpParams::RequantizeOpParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::RequantizeOpParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyEltwiseQuantizationOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseQuantizationOpParams> *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 (!VerifyEltwiseQuantizationOpParams(
        verifier,  values->Get(i), types->GetEnum<EltwiseQuantizationOpParams>(i))) {
      return false;
    }
  }
  return true;
}
 
inline bool VerifyEltwiseUnaryOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseUnaryOpParams type) {
  switch (type) {
    case EltwiseUnaryOpParams::NONE: {
      return true;
    }
    case EltwiseUnaryOpParams::EltwiseOpWithFloatParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::EltwiseOpWithFloatParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyEltwiseUnaryOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseUnaryOpParams> *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 (!VerifyEltwiseUnaryOpParams(
        verifier,  values->Get(i), types->GetEnum<EltwiseUnaryOpParams>(i))) {
      return false;
    }
  }
  return true;
}
 
inline bool VerifyEltwiseUnaryCompositeOpParams(::flatbuffers::Verifier &verifier, const void *obj, EltwiseUnaryCompositeOpParams type) {
  switch (type) {
    case EltwiseUnaryCompositeOpParams::NONE: {
      return true;
    }
    case EltwiseUnaryCompositeOpParams::ClampScalarOpParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ClampScalarOpParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case EltwiseUnaryCompositeOpParams::ClampTensorOpParams: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::ClampTensorOpParams *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyEltwiseUnaryCompositeOpParamsVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<EltwiseUnaryCompositeOpParams> *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 (!VerifyEltwiseUnaryCompositeOpParams(
        verifier,  values->Get(i), types->GetEnum<EltwiseUnaryCompositeOpParams>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_ELTWISE_TT_TARGET_TTNN_H_