// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_POINTWISEATTRIBUTES_HIPDNN_SDK_DATA_OBJECTS_H_
#define FLATBUFFERS_GENERATED_POINTWISEATTRIBUTES_HIPDNN_SDK_DATA_OBJECTS_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 == 25 &&
              FLATBUFFERS_VERSION_MINOR == 12 &&
              FLATBUFFERS_VERSION_REVISION == 19,
             "Non-compatible flatbuffers version included");

#include "data_types_generated.h"

namespace hipdnn_sdk {
namespace data_objects {

struct PointwiseAttributes;
struct PointwiseAttributesBuilder;
struct PointwiseAttributesT;

bool operator==(const PointwiseAttributesT &lhs, const PointwiseAttributesT &rhs);
bool operator!=(const PointwiseAttributesT &lhs, const PointwiseAttributesT &rhs);

enum class PointwiseMode : int8_t {
  UNSET = 0,
  ABS = 1,
  ADD = 2,
  ADD_SQUARE = 3,
  BINARY_SELECT = 4,
  CEIL = 5,
  CMP_EQ = 6,
  CMP_GE = 7,
  CMP_GT = 8,
  CMP_LE = 9,
  CMP_LT = 10,
  CMP_NEQ = 11,
  DIV = 12,
  ELU_BWD = 13,
  ELU_FWD = 14,
  ERF = 15,
  EXP = 16,
  FLOOR = 17,
  GELU_APPROX_TANH_BWD = 18,
  GELU_APPROX_TANH_FWD = 19,
  GELU_BWD = 20,
  GELU_FWD = 21,
  GEN_INDEX = 22,
  IDENTITY = 23,
  LOG = 24,
  LOGICAL_AND = 25,
  LOGICAL_NOT = 26,
  LOGICAL_OR = 27,
  MAX_OP = 28,
  MIN_OP = 29,
  MUL = 30,
  NEG = 31,
  RECIPROCAL = 32,
  RELU_BWD = 33,
  RELU_FWD = 34,
  RSQRT = 35,
  SIGMOID_BWD = 36,
  SIGMOID_FWD = 37,
  SIN = 38,
  SOFTPLUS_BWD = 39,
  SOFTPLUS_FWD = 40,
  SQRT = 41,
  SUB = 42,
  SWISH_BWD = 43,
  SWISH_FWD = 44,
  TAN = 45,
  TANH_BWD = 46,
  TANH_FWD = 47,
  MIN = UNSET,
  MAX = TANH_FWD
};

inline const PointwiseMode (&EnumValuesPointwiseMode())[48] {
  static const PointwiseMode values[] = {
    PointwiseMode::UNSET,
    PointwiseMode::ABS,
    PointwiseMode::ADD,
    PointwiseMode::ADD_SQUARE,
    PointwiseMode::BINARY_SELECT,
    PointwiseMode::CEIL,
    PointwiseMode::CMP_EQ,
    PointwiseMode::CMP_GE,
    PointwiseMode::CMP_GT,
    PointwiseMode::CMP_LE,
    PointwiseMode::CMP_LT,
    PointwiseMode::CMP_NEQ,
    PointwiseMode::DIV,
    PointwiseMode::ELU_BWD,
    PointwiseMode::ELU_FWD,
    PointwiseMode::ERF,
    PointwiseMode::EXP,
    PointwiseMode::FLOOR,
    PointwiseMode::GELU_APPROX_TANH_BWD,
    PointwiseMode::GELU_APPROX_TANH_FWD,
    PointwiseMode::GELU_BWD,
    PointwiseMode::GELU_FWD,
    PointwiseMode::GEN_INDEX,
    PointwiseMode::IDENTITY,
    PointwiseMode::LOG,
    PointwiseMode::LOGICAL_AND,
    PointwiseMode::LOGICAL_NOT,
    PointwiseMode::LOGICAL_OR,
    PointwiseMode::MAX_OP,
    PointwiseMode::MIN_OP,
    PointwiseMode::MUL,
    PointwiseMode::NEG,
    PointwiseMode::RECIPROCAL,
    PointwiseMode::RELU_BWD,
    PointwiseMode::RELU_FWD,
    PointwiseMode::RSQRT,
    PointwiseMode::SIGMOID_BWD,
    PointwiseMode::SIGMOID_FWD,
    PointwiseMode::SIN,
    PointwiseMode::SOFTPLUS_BWD,
    PointwiseMode::SOFTPLUS_FWD,
    PointwiseMode::SQRT,
    PointwiseMode::SUB,
    PointwiseMode::SWISH_BWD,
    PointwiseMode::SWISH_FWD,
    PointwiseMode::TAN,
    PointwiseMode::TANH_BWD,
    PointwiseMode::TANH_FWD
  };
  return values;
}

inline const char * const *EnumNamesPointwiseMode() {
  static const char * const names[49] = {
    "UNSET",
    "ABS",
    "ADD",
    "ADD_SQUARE",
    "BINARY_SELECT",
    "CEIL",
    "CMP_EQ",
    "CMP_GE",
    "CMP_GT",
    "CMP_LE",
    "CMP_LT",
    "CMP_NEQ",
    "DIV",
    "ELU_BWD",
    "ELU_FWD",
    "ERF",
    "EXP",
    "FLOOR",
    "GELU_APPROX_TANH_BWD",
    "GELU_APPROX_TANH_FWD",
    "GELU_BWD",
    "GELU_FWD",
    "GEN_INDEX",
    "IDENTITY",
    "LOG",
    "LOGICAL_AND",
    "LOGICAL_NOT",
    "LOGICAL_OR",
    "MAX_OP",
    "MIN_OP",
    "MUL",
    "NEG",
    "RECIPROCAL",
    "RELU_BWD",
    "RELU_FWD",
    "RSQRT",
    "SIGMOID_BWD",
    "SIGMOID_FWD",
    "SIN",
    "SOFTPLUS_BWD",
    "SOFTPLUS_FWD",
    "SQRT",
    "SUB",
    "SWISH_BWD",
    "SWISH_FWD",
    "TAN",
    "TANH_BWD",
    "TANH_FWD",
    nullptr
  };
  return names;
}

inline const char *EnumNamePointwiseMode(PointwiseMode e) {
  if (::flatbuffers::IsOutRange(e, PointwiseMode::UNSET, PointwiseMode::TANH_FWD)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesPointwiseMode()[index];
}

struct PointwiseAttributesT : public ::flatbuffers::NativeTable {
  typedef PointwiseAttributes TableType;
  hipdnn_sdk::data_objects::PointwiseMode operation = hipdnn_sdk::data_objects::PointwiseMode::UNSET;
  ::flatbuffers::Optional<float> relu_lower_clip = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<float> relu_upper_clip = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<float> relu_lower_clip_slope = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<int64_t> axis_tensor_uid = ::flatbuffers::nullopt;
  int64_t in_0_tensor_uid = 0;
  ::flatbuffers::Optional<int64_t> in_1_tensor_uid = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<int64_t> in_2_tensor_uid = ::flatbuffers::nullopt;
  int64_t out_0_tensor_uid = 0;
  ::flatbuffers::Optional<float> swish_beta = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<float> elu_alpha = ::flatbuffers::nullopt;
  ::flatbuffers::Optional<float> softplus_beta = ::flatbuffers::nullopt;
};

struct PointwiseAttributes FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PointwiseAttributesT NativeTableType;
  typedef PointwiseAttributesBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OPERATION = 4,
    VT_RELU_LOWER_CLIP = 6,
    VT_RELU_UPPER_CLIP = 8,
    VT_RELU_LOWER_CLIP_SLOPE = 10,
    VT_AXIS_TENSOR_UID = 12,
    VT_IN_0_TENSOR_UID = 14,
    VT_IN_1_TENSOR_UID = 16,
    VT_IN_2_TENSOR_UID = 18,
    VT_OUT_0_TENSOR_UID = 20,
    VT_SWISH_BETA = 22,
    VT_ELU_ALPHA = 24,
    VT_SOFTPLUS_BETA = 26
  };
  hipdnn_sdk::data_objects::PointwiseMode operation() const {
    return static_cast<hipdnn_sdk::data_objects::PointwiseMode>(GetField<int8_t>(VT_OPERATION, 0));
  }
  bool mutate_operation(hipdnn_sdk::data_objects::PointwiseMode _operation = static_cast<hipdnn_sdk::data_objects::PointwiseMode>(0)) {
    return SetField<int8_t>(VT_OPERATION, static_cast<int8_t>(_operation), 0);
  }
  ::flatbuffers::Optional<float> relu_lower_clip() const {
    return GetOptional<float, float>(VT_RELU_LOWER_CLIP);
  }
  bool mutate_relu_lower_clip(float _relu_lower_clip) {
    return SetField<float>(VT_RELU_LOWER_CLIP, _relu_lower_clip);
  }
  ::flatbuffers::Optional<float> relu_upper_clip() const {
    return GetOptional<float, float>(VT_RELU_UPPER_CLIP);
  }
  bool mutate_relu_upper_clip(float _relu_upper_clip) {
    return SetField<float>(VT_RELU_UPPER_CLIP, _relu_upper_clip);
  }
  ::flatbuffers::Optional<float> relu_lower_clip_slope() const {
    return GetOptional<float, float>(VT_RELU_LOWER_CLIP_SLOPE);
  }
  bool mutate_relu_lower_clip_slope(float _relu_lower_clip_slope) {
    return SetField<float>(VT_RELU_LOWER_CLIP_SLOPE, _relu_lower_clip_slope);
  }
  ::flatbuffers::Optional<int64_t> axis_tensor_uid() const {
    return GetOptional<int64_t, int64_t>(VT_AXIS_TENSOR_UID);
  }
  bool mutate_axis_tensor_uid(int64_t _axis_tensor_uid) {
    return SetField<int64_t>(VT_AXIS_TENSOR_UID, _axis_tensor_uid);
  }
  int64_t in_0_tensor_uid() const {
    return GetField<int64_t>(VT_IN_0_TENSOR_UID, 0);
  }
  bool mutate_in_0_tensor_uid(int64_t _in_0_tensor_uid = 0) {
    return SetField<int64_t>(VT_IN_0_TENSOR_UID, _in_0_tensor_uid, 0);
  }
  ::flatbuffers::Optional<int64_t> in_1_tensor_uid() const {
    return GetOptional<int64_t, int64_t>(VT_IN_1_TENSOR_UID);
  }
  bool mutate_in_1_tensor_uid(int64_t _in_1_tensor_uid) {
    return SetField<int64_t>(VT_IN_1_TENSOR_UID, _in_1_tensor_uid);
  }
  ::flatbuffers::Optional<int64_t> in_2_tensor_uid() const {
    return GetOptional<int64_t, int64_t>(VT_IN_2_TENSOR_UID);
  }
  bool mutate_in_2_tensor_uid(int64_t _in_2_tensor_uid) {
    return SetField<int64_t>(VT_IN_2_TENSOR_UID, _in_2_tensor_uid);
  }
  int64_t out_0_tensor_uid() const {
    return GetField<int64_t>(VT_OUT_0_TENSOR_UID, 0);
  }
  bool mutate_out_0_tensor_uid(int64_t _out_0_tensor_uid = 0) {
    return SetField<int64_t>(VT_OUT_0_TENSOR_UID, _out_0_tensor_uid, 0);
  }
  ::flatbuffers::Optional<float> swish_beta() const {
    return GetOptional<float, float>(VT_SWISH_BETA);
  }
  bool mutate_swish_beta(float _swish_beta) {
    return SetField<float>(VT_SWISH_BETA, _swish_beta);
  }
  ::flatbuffers::Optional<float> elu_alpha() const {
    return GetOptional<float, float>(VT_ELU_ALPHA);
  }
  bool mutate_elu_alpha(float _elu_alpha) {
    return SetField<float>(VT_ELU_ALPHA, _elu_alpha);
  }
  ::flatbuffers::Optional<float> softplus_beta() const {
    return GetOptional<float, float>(VT_SOFTPLUS_BETA);
  }
  bool mutate_softplus_beta(float _softplus_beta) {
    return SetField<float>(VT_SOFTPLUS_BETA, _softplus_beta);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_OPERATION, 1) &&
           VerifyField<float>(verifier, VT_RELU_LOWER_CLIP, 4) &&
           VerifyField<float>(verifier, VT_RELU_UPPER_CLIP, 4) &&
           VerifyField<float>(verifier, VT_RELU_LOWER_CLIP_SLOPE, 4) &&
           VerifyField<int64_t>(verifier, VT_AXIS_TENSOR_UID, 8) &&
           VerifyField<int64_t>(verifier, VT_IN_0_TENSOR_UID, 8) &&
           VerifyField<int64_t>(verifier, VT_IN_1_TENSOR_UID, 8) &&
           VerifyField<int64_t>(verifier, VT_IN_2_TENSOR_UID, 8) &&
           VerifyField<int64_t>(verifier, VT_OUT_0_TENSOR_UID, 8) &&
           VerifyField<float>(verifier, VT_SWISH_BETA, 4) &&
           VerifyField<float>(verifier, VT_ELU_ALPHA, 4) &&
           VerifyField<float>(verifier, VT_SOFTPLUS_BETA, 4) &&
           verifier.EndTable();
  }
  PointwiseAttributesT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PointwiseAttributesT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static ::flatbuffers::Offset<PointwiseAttributes> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PointwiseAttributesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PointwiseAttributesBuilder {
  typedef PointwiseAttributes Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_operation(hipdnn_sdk::data_objects::PointwiseMode operation) {
    fbb_.AddElement<int8_t>(PointwiseAttributes::VT_OPERATION, static_cast<int8_t>(operation), 0);
  }
  void add_relu_lower_clip(float relu_lower_clip) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_RELU_LOWER_CLIP, relu_lower_clip);
  }
  void add_relu_upper_clip(float relu_upper_clip) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_RELU_UPPER_CLIP, relu_upper_clip);
  }
  void add_relu_lower_clip_slope(float relu_lower_clip_slope) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_RELU_LOWER_CLIP_SLOPE, relu_lower_clip_slope);
  }
  void add_axis_tensor_uid(int64_t axis_tensor_uid) {
    fbb_.AddElement<int64_t>(PointwiseAttributes::VT_AXIS_TENSOR_UID, axis_tensor_uid);
  }
  void add_in_0_tensor_uid(int64_t in_0_tensor_uid) {
    fbb_.AddElement<int64_t>(PointwiseAttributes::VT_IN_0_TENSOR_UID, in_0_tensor_uid, 0);
  }
  void add_in_1_tensor_uid(int64_t in_1_tensor_uid) {
    fbb_.AddElement<int64_t>(PointwiseAttributes::VT_IN_1_TENSOR_UID, in_1_tensor_uid);
  }
  void add_in_2_tensor_uid(int64_t in_2_tensor_uid) {
    fbb_.AddElement<int64_t>(PointwiseAttributes::VT_IN_2_TENSOR_UID, in_2_tensor_uid);
  }
  void add_out_0_tensor_uid(int64_t out_0_tensor_uid) {
    fbb_.AddElement<int64_t>(PointwiseAttributes::VT_OUT_0_TENSOR_UID, out_0_tensor_uid, 0);
  }
  void add_swish_beta(float swish_beta) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_SWISH_BETA, swish_beta);
  }
  void add_elu_alpha(float elu_alpha) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_ELU_ALPHA, elu_alpha);
  }
  void add_softplus_beta(float softplus_beta) {
    fbb_.AddElement<float>(PointwiseAttributes::VT_SOFTPLUS_BETA, softplus_beta);
  }
  explicit PointwiseAttributesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PointwiseAttributes> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PointwiseAttributes>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PointwiseAttributes> CreatePointwiseAttributes(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    hipdnn_sdk::data_objects::PointwiseMode operation = hipdnn_sdk::data_objects::PointwiseMode::UNSET,
    ::flatbuffers::Optional<float> relu_lower_clip = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<float> relu_upper_clip = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<float> relu_lower_clip_slope = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<int64_t> axis_tensor_uid = ::flatbuffers::nullopt,
    int64_t in_0_tensor_uid = 0,
    ::flatbuffers::Optional<int64_t> in_1_tensor_uid = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<int64_t> in_2_tensor_uid = ::flatbuffers::nullopt,
    int64_t out_0_tensor_uid = 0,
    ::flatbuffers::Optional<float> swish_beta = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<float> elu_alpha = ::flatbuffers::nullopt,
    ::flatbuffers::Optional<float> softplus_beta = ::flatbuffers::nullopt) {
  PointwiseAttributesBuilder builder_(_fbb);
  builder_.add_out_0_tensor_uid(out_0_tensor_uid);
  if(in_2_tensor_uid) { builder_.add_in_2_tensor_uid(*in_2_tensor_uid); }
  if(in_1_tensor_uid) { builder_.add_in_1_tensor_uid(*in_1_tensor_uid); }
  builder_.add_in_0_tensor_uid(in_0_tensor_uid);
  if(axis_tensor_uid) { builder_.add_axis_tensor_uid(*axis_tensor_uid); }
  if(softplus_beta) { builder_.add_softplus_beta(*softplus_beta); }
  if(elu_alpha) { builder_.add_elu_alpha(*elu_alpha); }
  if(swish_beta) { builder_.add_swish_beta(*swish_beta); }
  if(relu_lower_clip_slope) { builder_.add_relu_lower_clip_slope(*relu_lower_clip_slope); }
  if(relu_upper_clip) { builder_.add_relu_upper_clip(*relu_upper_clip); }
  if(relu_lower_clip) { builder_.add_relu_lower_clip(*relu_lower_clip); }
  builder_.add_operation(operation);
  return builder_.Finish();
}

::flatbuffers::Offset<PointwiseAttributes> CreatePointwiseAttributes(::flatbuffers::FlatBufferBuilder &_fbb, const PointwiseAttributesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);


inline bool operator==(const PointwiseAttributesT &lhs, const PointwiseAttributesT &rhs) {
  return
      (lhs.operation == rhs.operation) &&
      (lhs.relu_lower_clip == rhs.relu_lower_clip) &&
      (lhs.relu_upper_clip == rhs.relu_upper_clip) &&
      (lhs.relu_lower_clip_slope == rhs.relu_lower_clip_slope) &&
      (lhs.axis_tensor_uid == rhs.axis_tensor_uid) &&
      (lhs.in_0_tensor_uid == rhs.in_0_tensor_uid) &&
      (lhs.in_1_tensor_uid == rhs.in_1_tensor_uid) &&
      (lhs.in_2_tensor_uid == rhs.in_2_tensor_uid) &&
      (lhs.out_0_tensor_uid == rhs.out_0_tensor_uid) &&
      (lhs.swish_beta == rhs.swish_beta) &&
      (lhs.elu_alpha == rhs.elu_alpha) &&
      (lhs.softplus_beta == rhs.softplus_beta);
}

inline bool operator!=(const PointwiseAttributesT &lhs, const PointwiseAttributesT &rhs) {
    return !(lhs == rhs);
}


inline PointwiseAttributesT *PointwiseAttributes::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
  auto _o = std::unique_ptr<PointwiseAttributesT>(new PointwiseAttributesT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PointwiseAttributes::UnPackTo(PointwiseAttributesT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = operation(); _o->operation = _e; }
  { auto _e = relu_lower_clip(); _o->relu_lower_clip = _e; }
  { auto _e = relu_upper_clip(); _o->relu_upper_clip = _e; }
  { auto _e = relu_lower_clip_slope(); _o->relu_lower_clip_slope = _e; }
  { auto _e = axis_tensor_uid(); _o->axis_tensor_uid = _e; }
  { auto _e = in_0_tensor_uid(); _o->in_0_tensor_uid = _e; }
  { auto _e = in_1_tensor_uid(); _o->in_1_tensor_uid = _e; }
  { auto _e = in_2_tensor_uid(); _o->in_2_tensor_uid = _e; }
  { auto _e = out_0_tensor_uid(); _o->out_0_tensor_uid = _e; }
  { auto _e = swish_beta(); _o->swish_beta = _e; }
  { auto _e = elu_alpha(); _o->elu_alpha = _e; }
  { auto _e = softplus_beta(); _o->softplus_beta = _e; }
}

inline ::flatbuffers::Offset<PointwiseAttributes> CreatePointwiseAttributes(::flatbuffers::FlatBufferBuilder &_fbb, const PointwiseAttributesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  return PointwiseAttributes::Pack(_fbb, _o, _rehasher);
}

inline ::flatbuffers::Offset<PointwiseAttributes> PointwiseAttributes::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PointwiseAttributesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PointwiseAttributesT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _operation = _o->operation;
  auto _relu_lower_clip = _o->relu_lower_clip;
  auto _relu_upper_clip = _o->relu_upper_clip;
  auto _relu_lower_clip_slope = _o->relu_lower_clip_slope;
  auto _axis_tensor_uid = _o->axis_tensor_uid;
  auto _in_0_tensor_uid = _o->in_0_tensor_uid;
  auto _in_1_tensor_uid = _o->in_1_tensor_uid;
  auto _in_2_tensor_uid = _o->in_2_tensor_uid;
  auto _out_0_tensor_uid = _o->out_0_tensor_uid;
  auto _swish_beta = _o->swish_beta;
  auto _elu_alpha = _o->elu_alpha;
  auto _softplus_beta = _o->softplus_beta;
  return hipdnn_sdk::data_objects::CreatePointwiseAttributes(
      _fbb,
      _operation,
      _relu_lower_clip,
      _relu_upper_clip,
      _relu_lower_clip_slope,
      _axis_tensor_uid,
      _in_0_tensor_uid,
      _in_1_tensor_uid,
      _in_2_tensor_uid,
      _out_0_tensor_uid,
      _swish_beta,
      _elu_alpha,
      _softplus_beta);
}

}  // namespace data_objects
}  // namespace hipdnn_sdk

#endif  // FLATBUFFERS_GENERATED_POINTWISEATTRIBUTES_HIPDNN_SDK_DATA_OBJECTS_H_
