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


#ifndef FLATBUFFERS_GENERATED_SUPERACMEQUANTIZEOP_MNN_H_
#define FLATBUFFERS_GENERATED_SUPERACMEQUANTIZEOP_MNN_H_


#include "Tensor_generated.h"
#include "Type_generated.h"

namespace MNN {

struct Conv2dSuperAcmeQuantizedParam;
struct Conv2dSuperAcmeQuantizedParamT;

struct EltwiseSuperAcmeQuantizedParam;
struct EltwiseSuperAcmeQuantizedParamT;

struct PoolingSuperAcmeQuantizedParam;
struct PoolingSuperAcmeQuantizedParamT;

struct ReluSuperAcmeQuantizedParam;
struct ReluSuperAcmeQuantizedParamT;

struct PReluSuperAcmeQuantizedParam;
struct PReluSuperAcmeQuantizedParamT;

struct LutSuperAcmeQuantizedParam;
struct LutSuperAcmeQuantizedParamT;

struct InterpSuperAcmeQuantizedParam;
struct InterpSuperAcmeQuantizedParamT;

struct BinarySuperAcmeQuantizedParam;
struct BinarySuperAcmeQuantizedParamT;

struct ScaleSuperAcmeQuantizedParam;
struct ScaleSuperAcmeQuantizedParamT;

struct MatMulSuperAcmeQuantizedParam;
struct MatMulSuperAcmeQuantizedParamT;

struct ArgMaxSuperAcmeQuantizedParam;
struct ArgMaxSuperAcmeQuantizedParamT;

struct ReductionSuperAcmeQuantizedParam;
struct ReductionSuperAcmeQuantizedParamT;

struct Relu6SuperAcmeQuantizedParam;
struct Relu6SuperAcmeQuantizedParamT;

inline const flatbuffers::TypeTable *Conv2dSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *EltwiseSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *PoolingSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *ReluSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *PReluSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *LutSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *InterpSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *BinarySuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *ScaleSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *MatMulSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *ArgMaxSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *ReductionSuperAcmeQuantizedParamTypeTable();

inline const flatbuffers::TypeTable *Relu6SuperAcmeQuantizedParamTypeTable();

struct Conv2dSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef Conv2dSuperAcmeQuantizedParam TableType;
  std::vector<int32_t> mquantizeMultiplier;
  std::vector<int32_t> mRightShift;
  std::vector<int32_t> mintbias;
  int32_t mmode;
  DataType weightType;
  Conv2dSuperAcmeQuantizedParamT()
      : mmode(0),
        weightType(DataType_DT_INT8) {
  }
};

struct Conv2dSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef Conv2dSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Conv2dSuperAcmeQuantizedParamTypeTable();
  }
  const flatbuffers::Vector<int32_t> *mquantizeMultiplier() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
  }
  const flatbuffers::Vector<int32_t> *mRightShift() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(6);
  }
  const flatbuffers::Vector<int32_t> *mintbias() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(8);
  }
  int32_t mmode() const {
    return GetField<int32_t>(10, 0);
  }
  DataType weightType() const {
    return static_cast<DataType>(GetField<int32_t>(12, 6));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, 4) &&
           verifier.VerifyVector(mquantizeMultiplier()) &&
           VerifyOffset(verifier, 6) &&
           verifier.VerifyVector(mRightShift()) &&
           VerifyOffset(verifier, 8) &&
           verifier.VerifyVector(mintbias()) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           verifier.EndTable();
  }
  Conv2dSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(Conv2dSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2dSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct Conv2dSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_mquantizeMultiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mquantizeMultiplier) {
    fbb_.AddOffset(4, mquantizeMultiplier);
  }
  void add_mRightShift(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShift) {
    fbb_.AddOffset(6, mRightShift);
  }
  void add_mintbias(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbias) {
    fbb_.AddOffset(8, mintbias);
  }
  void add_mmode(int32_t mmode) {
    fbb_.AddElement<int32_t>(10, mmode, 0);
  }
  void add_weightType(DataType weightType) {
    fbb_.AddElement<int32_t>(12, static_cast<int32_t>(weightType), 6);
  }
  explicit Conv2dSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  Conv2dSuperAcmeQuantizedParamBuilder &operator=(const Conv2dSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> CreateConv2dSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mquantizeMultiplier = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShift = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbias = 0,
    int32_t mmode = 0,
    DataType weightType = DataType_DT_INT8) {
  Conv2dSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_weightType(weightType);
  builder_.add_mmode(mmode);
  builder_.add_mintbias(mintbias);
  builder_.add_mRightShift(mRightShift);
  builder_.add_mquantizeMultiplier(mquantizeMultiplier);
  return builder_.Finish();
}

flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> CreateConv2dSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const Conv2dSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct EltwiseSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef EltwiseSuperAcmeQuantizedParam TableType;
  int32_t input1Offset;
  int32_t input2Offset;
  int32_t outputOffset;
  int32_t input1Multiplier;
  int32_t input2Multiplier;
  int32_t outputMultiplier;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  int32_t mLeftShiftResult1;
  int32_t mLeftShiftResult2;
  int32_t mRightShift1;
  int32_t mRightShift2;
  int32_t mLeftShiftOut;
  int32_t mRightShiftOut;
  int32_t mode;
  EltwiseSuperAcmeQuantizedParamT()
      : input1Offset(0),
        input2Offset(0),
        outputOffset(0),
        input1Multiplier(0),
        input2Multiplier(0),
        outputMultiplier(0),
        outputActivationMin(0),
        outputActivationMax(0),
        mLeftShiftResult1(0),
        mLeftShiftResult2(0),
        mRightShift1(0),
        mRightShift2(0),
        mLeftShiftOut(0),
        mRightShiftOut(0),
        mode(0) {
  }
};

struct EltwiseSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef EltwiseSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return EltwiseSuperAcmeQuantizedParamTypeTable();
  }
  int32_t input1Offset() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t input2Offset() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t outputOffset() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t input1Multiplier() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t input2Multiplier() const {
    return GetField<int32_t>(12, 0);
  }
  int32_t outputMultiplier() const {
    return GetField<int32_t>(14, 0);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(16, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(18, 0);
  }
  int32_t mLeftShiftResult1() const {
    return GetField<int32_t>(20, 0);
  }
  int32_t mLeftShiftResult2() const {
    return GetField<int32_t>(22, 0);
  }
  int32_t mRightShift1() const {
    return GetField<int32_t>(24, 0);
  }
  int32_t mRightShift2() const {
    return GetField<int32_t>(26, 0);
  }
  int32_t mLeftShiftOut() const {
    return GetField<int32_t>(28, 0);
  }
  int32_t mRightShiftOut() const {
    return GetField<int32_t>(30, 0);
  }
  int32_t mode() const {
    return GetField<int32_t>(32, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           VerifyField<int32_t>(verifier, 14) &&
           VerifyField<int32_t>(verifier, 16) &&
           VerifyField<int32_t>(verifier, 18) &&
           VerifyField<int32_t>(verifier, 20) &&
           VerifyField<int32_t>(verifier, 22) &&
           VerifyField<int32_t>(verifier, 24) &&
           VerifyField<int32_t>(verifier, 26) &&
           VerifyField<int32_t>(verifier, 28) &&
           VerifyField<int32_t>(verifier, 30) &&
           VerifyField<int32_t>(verifier, 32) &&
           verifier.EndTable();
  }
  EltwiseSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(EltwiseSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EltwiseSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct EltwiseSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_input1Offset(int32_t input1Offset) {
    fbb_.AddElement<int32_t>(4, input1Offset, 0);
  }
  void add_input2Offset(int32_t input2Offset) {
    fbb_.AddElement<int32_t>(6, input2Offset, 0);
  }
  void add_outputOffset(int32_t outputOffset) {
    fbb_.AddElement<int32_t>(8, outputOffset, 0);
  }
  void add_input1Multiplier(int32_t input1Multiplier) {
    fbb_.AddElement<int32_t>(10, input1Multiplier, 0);
  }
  void add_input2Multiplier(int32_t input2Multiplier) {
    fbb_.AddElement<int32_t>(12, input2Multiplier, 0);
  }
  void add_outputMultiplier(int32_t outputMultiplier) {
    fbb_.AddElement<int32_t>(14, outputMultiplier, 0);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(16, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(18, outputActivationMax, 0);
  }
  void add_mLeftShiftResult1(int32_t mLeftShiftResult1) {
    fbb_.AddElement<int32_t>(20, mLeftShiftResult1, 0);
  }
  void add_mLeftShiftResult2(int32_t mLeftShiftResult2) {
    fbb_.AddElement<int32_t>(22, mLeftShiftResult2, 0);
  }
  void add_mRightShift1(int32_t mRightShift1) {
    fbb_.AddElement<int32_t>(24, mRightShift1, 0);
  }
  void add_mRightShift2(int32_t mRightShift2) {
    fbb_.AddElement<int32_t>(26, mRightShift2, 0);
  }
  void add_mLeftShiftOut(int32_t mLeftShiftOut) {
    fbb_.AddElement<int32_t>(28, mLeftShiftOut, 0);
  }
  void add_mRightShiftOut(int32_t mRightShiftOut) {
    fbb_.AddElement<int32_t>(30, mRightShiftOut, 0);
  }
  void add_mode(int32_t mode) {
    fbb_.AddElement<int32_t>(32, mode, 0);
  }
  explicit EltwiseSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  EltwiseSuperAcmeQuantizedParamBuilder &operator=(const EltwiseSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> CreateEltwiseSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t input1Offset = 0,
    int32_t input2Offset = 0,
    int32_t outputOffset = 0,
    int32_t input1Multiplier = 0,
    int32_t input2Multiplier = 0,
    int32_t outputMultiplier = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0,
    int32_t mLeftShiftResult1 = 0,
    int32_t mLeftShiftResult2 = 0,
    int32_t mRightShift1 = 0,
    int32_t mRightShift2 = 0,
    int32_t mLeftShiftOut = 0,
    int32_t mRightShiftOut = 0,
    int32_t mode = 0) {
  EltwiseSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_mode(mode);
  builder_.add_mRightShiftOut(mRightShiftOut);
  builder_.add_mLeftShiftOut(mLeftShiftOut);
  builder_.add_mRightShift2(mRightShift2);
  builder_.add_mRightShift1(mRightShift1);
  builder_.add_mLeftShiftResult2(mLeftShiftResult2);
  builder_.add_mLeftShiftResult1(mLeftShiftResult1);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_outputMultiplier(outputMultiplier);
  builder_.add_input2Multiplier(input2Multiplier);
  builder_.add_input1Multiplier(input1Multiplier);
  builder_.add_outputOffset(outputOffset);
  builder_.add_input2Offset(input2Offset);
  builder_.add_input1Offset(input1Offset);
  return builder_.Finish();
}

flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> CreateEltwiseSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const EltwiseSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PoolingSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef PoolingSuperAcmeQuantizedParam TableType;
  bool needscale;
  int32_t inputOffset;
  int32_t outputOffset;
  int32_t outputMultiplier;
  int32_t outputShift;
  PoolingSuperAcmeQuantizedParamT()
      : needscale(true),
        inputOffset(0),
        outputOffset(0),
        outputMultiplier(0),
        outputShift(0) {
  }
};

struct PoolingSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PoolingSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PoolingSuperAcmeQuantizedParamTypeTable();
  }
  bool needscale() const {
    return GetField<uint8_t>(4, 1) != 0;
  }
  int32_t inputOffset() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t outputOffset() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t outputMultiplier() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t outputShift() const {
    return GetField<int32_t>(12, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           verifier.EndTable();
  }
  PoolingSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PoolingSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PoolingSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PoolingSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_needscale(bool needscale) {
    fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(needscale), 1);
  }
  void add_inputOffset(int32_t inputOffset) {
    fbb_.AddElement<int32_t>(6, inputOffset, 0);
  }
  void add_outputOffset(int32_t outputOffset) {
    fbb_.AddElement<int32_t>(8, outputOffset, 0);
  }
  void add_outputMultiplier(int32_t outputMultiplier) {
    fbb_.AddElement<int32_t>(10, outputMultiplier, 0);
  }
  void add_outputShift(int32_t outputShift) {
    fbb_.AddElement<int32_t>(12, outputShift, 0);
  }
  explicit PoolingSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PoolingSuperAcmeQuantizedParamBuilder &operator=(const PoolingSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<PoolingSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> CreatePoolingSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool needscale = true,
    int32_t inputOffset = 0,
    int32_t outputOffset = 0,
    int32_t outputMultiplier = 0,
    int32_t outputShift = 0) {
  PoolingSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputShift(outputShift);
  builder_.add_outputMultiplier(outputMultiplier);
  builder_.add_outputOffset(outputOffset);
  builder_.add_inputOffset(inputOffset);
  builder_.add_needscale(needscale);
  return builder_.Finish();
}

flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> CreatePoolingSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const PoolingSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ReluSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef ReluSuperAcmeQuantizedParam TableType;
  int32_t inputZero;
  int32_t outputZero;
  int32_t inputScale;
  int32_t outputScale;
  ReluSuperAcmeQuantizedParamT()
      : inputZero(0),
        outputZero(0),
        inputScale(0),
        outputScale(0) {
  }
};

struct ReluSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ReluSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReluSuperAcmeQuantizedParamTypeTable();
  }
  int32_t inputZero() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t outputZero() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t inputScale() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t outputScale() const {
    return GetField<int32_t>(10, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           verifier.EndTable();
  }
  ReluSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(ReluSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<ReluSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReluSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct ReluSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_inputZero(int32_t inputZero) {
    fbb_.AddElement<int32_t>(4, inputZero, 0);
  }
  void add_outputZero(int32_t outputZero) {
    fbb_.AddElement<int32_t>(6, outputZero, 0);
  }
  void add_inputScale(int32_t inputScale) {
    fbb_.AddElement<int32_t>(8, inputScale, 0);
  }
  void add_outputScale(int32_t outputScale) {
    fbb_.AddElement<int32_t>(10, outputScale, 0);
  }
  explicit ReluSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ReluSuperAcmeQuantizedParamBuilder &operator=(const ReluSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<ReluSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ReluSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<ReluSuperAcmeQuantizedParam> CreateReluSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t inputZero = 0,
    int32_t outputZero = 0,
    int32_t inputScale = 0,
    int32_t outputScale = 0) {
  ReluSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputScale(outputScale);
  builder_.add_inputScale(inputScale);
  builder_.add_outputZero(outputZero);
  builder_.add_inputZero(inputZero);
  return builder_.Finish();
}

flatbuffers::Offset<ReluSuperAcmeQuantizedParam> CreateReluSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ReluSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PReluSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef PReluSuperAcmeQuantizedParam TableType;
  int32_t inputZero;
  int32_t outputZero;
  std::vector<int32_t> slope_q;
  std::vector<int32_t> mRightShiftQ;
  int32_t mRightShiftQ_;
  std::vector<int32_t> slope_p;
  std::vector<int32_t> mRightShiftP;
  int32_t mRightShiftP_;
  std::vector<int32_t> mintbiasQ;
  std::vector<int32_t> mintbiasP;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  PReluSuperAcmeQuantizedParamT()
      : inputZero(0),
        outputZero(0),
        mRightShiftQ_(0),
        mRightShiftP_(0),
        outputActivationMin(0),
        outputActivationMax(0) {
  }
};

struct PReluSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PReluSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return PReluSuperAcmeQuantizedParamTypeTable();
  }
  int32_t inputZero() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t outputZero() const {
    return GetField<int32_t>(6, 0);
  }
  const flatbuffers::Vector<int32_t> *slope_q() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(8);
  }
  const flatbuffers::Vector<int32_t> *mRightShiftQ() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(10);
  }
  int32_t mRightShiftQ_() const {
    return GetField<int32_t>(12, 0);
  }
  const flatbuffers::Vector<int32_t> *slope_p() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(14);
  }
  const flatbuffers::Vector<int32_t> *mRightShiftP() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(16);
  }
  int32_t mRightShiftP_() const {
    return GetField<int32_t>(18, 0);
  }
  const flatbuffers::Vector<int32_t> *mintbiasQ() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(20);
  }
  const flatbuffers::Vector<int32_t> *mintbiasP() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(22);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(24, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(26, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyOffset(verifier, 8) &&
           verifier.VerifyVector(slope_q()) &&
           VerifyOffset(verifier, 10) &&
           verifier.VerifyVector(mRightShiftQ()) &&
           VerifyField<int32_t>(verifier, 12) &&
           VerifyOffset(verifier, 14) &&
           verifier.VerifyVector(slope_p()) &&
           VerifyOffset(verifier, 16) &&
           verifier.VerifyVector(mRightShiftP()) &&
           VerifyField<int32_t>(verifier, 18) &&
           VerifyOffset(verifier, 20) &&
           verifier.VerifyVector(mintbiasQ()) &&
           VerifyOffset(verifier, 22) &&
           verifier.VerifyVector(mintbiasP()) &&
           VerifyField<int32_t>(verifier, 24) &&
           VerifyField<int32_t>(verifier, 26) &&
           verifier.EndTable();
  }
  PReluSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PReluSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PReluSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PReluSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PReluSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_inputZero(int32_t inputZero) {
    fbb_.AddElement<int32_t>(4, inputZero, 0);
  }
  void add_outputZero(int32_t outputZero) {
    fbb_.AddElement<int32_t>(6, outputZero, 0);
  }
  void add_slope_q(flatbuffers::Offset<flatbuffers::Vector<int32_t>> slope_q) {
    fbb_.AddOffset(8, slope_q);
  }
  void add_mRightShiftQ(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShiftQ) {
    fbb_.AddOffset(10, mRightShiftQ);
  }
  void add_mRightShiftQ_(int32_t mRightShiftQ_) {
    fbb_.AddElement<int32_t>(12, mRightShiftQ_, 0);
  }
  void add_slope_p(flatbuffers::Offset<flatbuffers::Vector<int32_t>> slope_p) {
    fbb_.AddOffset(14, slope_p);
  }
  void add_mRightShiftP(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShiftP) {
    fbb_.AddOffset(16, mRightShiftP);
  }
  void add_mRightShiftP_(int32_t mRightShiftP_) {
    fbb_.AddElement<int32_t>(18, mRightShiftP_, 0);
  }
  void add_mintbiasQ(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbiasQ) {
    fbb_.AddOffset(20, mintbiasQ);
  }
  void add_mintbiasP(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbiasP) {
    fbb_.AddOffset(22, mintbiasP);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(24, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(26, outputActivationMax, 0);
  }
  explicit PReluSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PReluSuperAcmeQuantizedParamBuilder &operator=(const PReluSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<PReluSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<PReluSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<PReluSuperAcmeQuantizedParam> CreatePReluSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t inputZero = 0,
    int32_t outputZero = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> slope_q = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShiftQ = 0,
    int32_t mRightShiftQ_ = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> slope_p = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mRightShiftP = 0,
    int32_t mRightShiftP_ = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbiasQ = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbiasP = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0) {
  PReluSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_mintbiasP(mintbiasP);
  builder_.add_mintbiasQ(mintbiasQ);
  builder_.add_mRightShiftP_(mRightShiftP_);
  builder_.add_mRightShiftP(mRightShiftP);
  builder_.add_slope_p(slope_p);
  builder_.add_mRightShiftQ_(mRightShiftQ_);
  builder_.add_mRightShiftQ(mRightShiftQ);
  builder_.add_slope_q(slope_q);
  builder_.add_outputZero(outputZero);
  builder_.add_inputZero(inputZero);
  return builder_.Finish();
}

flatbuffers::Offset<PReluSuperAcmeQuantizedParam> CreatePReluSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const PReluSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LutSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef LutSuperAcmeQuantizedParam TableType;
  bool lutFlag;
  std::vector<int8_t> lutTbl;
  int32_t inputZero;
  int32_t outputZero;
  double inputScale;
  double outputScale;
  LutSuperAcmeQuantizedParamT()
      : lutFlag(false),
        inputZero(0),
        outputZero(0),
        inputScale(0.0),
        outputScale(0.0) {
  }
};

struct LutSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LutSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return LutSuperAcmeQuantizedParamTypeTable();
  }
  bool lutFlag() const {
    return GetField<uint8_t>(4, 0) != 0;
  }
  const flatbuffers::Vector<int8_t> *lutTbl() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(6);
  }
  int32_t inputZero() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t outputZero() const {
    return GetField<int32_t>(10, 0);
  }
  double inputScale() const {
    return GetField<double>(12, 0.0);
  }
  double outputScale() const {
    return GetField<double>(14, 0.0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, 4) &&
           VerifyOffset(verifier, 6) &&
           verifier.VerifyVector(lutTbl()) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<double>(verifier, 12) &&
           VerifyField<double>(verifier, 14) &&
           verifier.EndTable();
  }
  LutSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LutSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LutSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LutSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LutSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_lutFlag(bool lutFlag) {
    fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(lutFlag), 0);
  }
  void add_lutTbl(flatbuffers::Offset<flatbuffers::Vector<int8_t>> lutTbl) {
    fbb_.AddOffset(6, lutTbl);
  }
  void add_inputZero(int32_t inputZero) {
    fbb_.AddElement<int32_t>(8, inputZero, 0);
  }
  void add_outputZero(int32_t outputZero) {
    fbb_.AddElement<int32_t>(10, outputZero, 0);
  }
  void add_inputScale(double inputScale) {
    fbb_.AddElement<double>(12, inputScale, 0.0);
  }
  void add_outputScale(double outputScale) {
    fbb_.AddElement<double>(14, outputScale, 0.0);
  }
  explicit LutSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LutSuperAcmeQuantizedParamBuilder &operator=(const LutSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<LutSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LutSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<LutSuperAcmeQuantizedParam> CreateLutSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool lutFlag = false,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> lutTbl = 0,
    int32_t inputZero = 0,
    int32_t outputZero = 0,
    double inputScale = 0.0,
    double outputScale = 0.0) {
  LutSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputScale(outputScale);
  builder_.add_inputScale(inputScale);
  builder_.add_outputZero(outputZero);
  builder_.add_inputZero(inputZero);
  builder_.add_lutTbl(lutTbl);
  builder_.add_lutFlag(lutFlag);
  return builder_.Finish();
}

flatbuffers::Offset<LutSuperAcmeQuantizedParam> CreateLutSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const LutSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct InterpSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef InterpSuperAcmeQuantizedParam TableType;
  int32_t mode;
  std::vector<int32_t> xPositions;
  std::vector<int32_t> yPositions;
  std::vector<int32_t> xFactors;
  std::vector<int32_t> yFactors;
  int32_t unifiedFactorShift;
  int8_t clampMin;
  int8_t clampMax;
  InterpSuperAcmeQuantizedParamT()
      : mode(0),
        unifiedFactorShift(0),
        clampMin(-128),
        clampMax(127) {
  }
};

struct InterpSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef InterpSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return InterpSuperAcmeQuantizedParamTypeTable();
  }
  int32_t mode() const {
    return GetField<int32_t>(4, 0);
  }
  const flatbuffers::Vector<int32_t> *xPositions() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(6);
  }
  const flatbuffers::Vector<int32_t> *yPositions() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(8);
  }
  const flatbuffers::Vector<int32_t> *xFactors() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(10);
  }
  const flatbuffers::Vector<int32_t> *yFactors() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(12);
  }
  int32_t unifiedFactorShift() const {
    return GetField<int32_t>(14, 0);
  }
  int8_t clampMin() const {
    return GetField<int8_t>(16, -128);
  }
  int8_t clampMax() const {
    return GetField<int8_t>(18, 127);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyOffset(verifier, 6) &&
           verifier.VerifyVector(xPositions()) &&
           VerifyOffset(verifier, 8) &&
           verifier.VerifyVector(yPositions()) &&
           VerifyOffset(verifier, 10) &&
           verifier.VerifyVector(xFactors()) &&
           VerifyOffset(verifier, 12) &&
           verifier.VerifyVector(yFactors()) &&
           VerifyField<int32_t>(verifier, 14) &&
           VerifyField<int8_t>(verifier, 16) &&
           VerifyField<int8_t>(verifier, 18) &&
           verifier.EndTable();
  }
  InterpSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(InterpSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<InterpSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const InterpSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct InterpSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_mode(int32_t mode) {
    fbb_.AddElement<int32_t>(4, mode, 0);
  }
  void add_xPositions(flatbuffers::Offset<flatbuffers::Vector<int32_t>> xPositions) {
    fbb_.AddOffset(6, xPositions);
  }
  void add_yPositions(flatbuffers::Offset<flatbuffers::Vector<int32_t>> yPositions) {
    fbb_.AddOffset(8, yPositions);
  }
  void add_xFactors(flatbuffers::Offset<flatbuffers::Vector<int32_t>> xFactors) {
    fbb_.AddOffset(10, xFactors);
  }
  void add_yFactors(flatbuffers::Offset<flatbuffers::Vector<int32_t>> yFactors) {
    fbb_.AddOffset(12, yFactors);
  }
  void add_unifiedFactorShift(int32_t unifiedFactorShift) {
    fbb_.AddElement<int32_t>(14, unifiedFactorShift, 0);
  }
  void add_clampMin(int8_t clampMin) {
    fbb_.AddElement<int8_t>(16, clampMin, -128);
  }
  void add_clampMax(int8_t clampMax) {
    fbb_.AddElement<int8_t>(18, clampMax, 127);
  }
  explicit InterpSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  InterpSuperAcmeQuantizedParamBuilder &operator=(const InterpSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<InterpSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<InterpSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<InterpSuperAcmeQuantizedParam> CreateInterpSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t mode = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> xPositions = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> yPositions = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> xFactors = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> yFactors = 0,
    int32_t unifiedFactorShift = 0,
    int8_t clampMin = -128,
    int8_t clampMax = 127) {
  InterpSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_unifiedFactorShift(unifiedFactorShift);
  builder_.add_yFactors(yFactors);
  builder_.add_xFactors(xFactors);
  builder_.add_yPositions(yPositions);
  builder_.add_xPositions(xPositions);
  builder_.add_mode(mode);
  builder_.add_clampMax(clampMax);
  builder_.add_clampMin(clampMin);
  return builder_.Finish();
}

flatbuffers::Offset<InterpSuperAcmeQuantizedParam> CreateInterpSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const InterpSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BinarySuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef BinarySuperAcmeQuantizedParam TableType;
  int32_t input1Offset;
  int32_t input2Offset;
  int32_t outputOffset;
  int32_t input1Multiplier;
  int32_t input2Multiplier;
  int32_t outputMultiplier;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  int32_t mLeftShiftResult1;
  int32_t mLeftShiftResult2;
  int32_t mRightShift1;
  int32_t mRightShift2;
  int32_t mLeftShiftOut;
  int32_t mRightShiftOut;
  int32_t type;
  BinarySuperAcmeQuantizedParamT()
      : input1Offset(0),
        input2Offset(0),
        outputOffset(0),
        input1Multiplier(0),
        input2Multiplier(0),
        outputMultiplier(0),
        outputActivationMin(0),
        outputActivationMax(0),
        mLeftShiftResult1(0),
        mLeftShiftResult2(0),
        mRightShift1(0),
        mRightShift2(0),
        mLeftShiftOut(0),
        mRightShiftOut(0),
        type(0) {
  }
};

struct BinarySuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BinarySuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return BinarySuperAcmeQuantizedParamTypeTable();
  }
  int32_t input1Offset() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t input2Offset() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t outputOffset() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t input1Multiplier() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t input2Multiplier() const {
    return GetField<int32_t>(12, 0);
  }
  int32_t outputMultiplier() const {
    return GetField<int32_t>(14, 0);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(16, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(18, 0);
  }
  int32_t mLeftShiftResult1() const {
    return GetField<int32_t>(20, 0);
  }
  int32_t mLeftShiftResult2() const {
    return GetField<int32_t>(22, 0);
  }
  int32_t mRightShift1() const {
    return GetField<int32_t>(24, 0);
  }
  int32_t mRightShift2() const {
    return GetField<int32_t>(26, 0);
  }
  int32_t mLeftShiftOut() const {
    return GetField<int32_t>(28, 0);
  }
  int32_t mRightShiftOut() const {
    return GetField<int32_t>(30, 0);
  }
  int32_t type() const {
    return GetField<int32_t>(32, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           VerifyField<int32_t>(verifier, 14) &&
           VerifyField<int32_t>(verifier, 16) &&
           VerifyField<int32_t>(verifier, 18) &&
           VerifyField<int32_t>(verifier, 20) &&
           VerifyField<int32_t>(verifier, 22) &&
           VerifyField<int32_t>(verifier, 24) &&
           VerifyField<int32_t>(verifier, 26) &&
           VerifyField<int32_t>(verifier, 28) &&
           VerifyField<int32_t>(verifier, 30) &&
           VerifyField<int32_t>(verifier, 32) &&
           verifier.EndTable();
  }
  BinarySuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(BinarySuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<BinarySuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BinarySuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct BinarySuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_input1Offset(int32_t input1Offset) {
    fbb_.AddElement<int32_t>(4, input1Offset, 0);
  }
  void add_input2Offset(int32_t input2Offset) {
    fbb_.AddElement<int32_t>(6, input2Offset, 0);
  }
  void add_outputOffset(int32_t outputOffset) {
    fbb_.AddElement<int32_t>(8, outputOffset, 0);
  }
  void add_input1Multiplier(int32_t input1Multiplier) {
    fbb_.AddElement<int32_t>(10, input1Multiplier, 0);
  }
  void add_input2Multiplier(int32_t input2Multiplier) {
    fbb_.AddElement<int32_t>(12, input2Multiplier, 0);
  }
  void add_outputMultiplier(int32_t outputMultiplier) {
    fbb_.AddElement<int32_t>(14, outputMultiplier, 0);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(16, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(18, outputActivationMax, 0);
  }
  void add_mLeftShiftResult1(int32_t mLeftShiftResult1) {
    fbb_.AddElement<int32_t>(20, mLeftShiftResult1, 0);
  }
  void add_mLeftShiftResult2(int32_t mLeftShiftResult2) {
    fbb_.AddElement<int32_t>(22, mLeftShiftResult2, 0);
  }
  void add_mRightShift1(int32_t mRightShift1) {
    fbb_.AddElement<int32_t>(24, mRightShift1, 0);
  }
  void add_mRightShift2(int32_t mRightShift2) {
    fbb_.AddElement<int32_t>(26, mRightShift2, 0);
  }
  void add_mLeftShiftOut(int32_t mLeftShiftOut) {
    fbb_.AddElement<int32_t>(28, mLeftShiftOut, 0);
  }
  void add_mRightShiftOut(int32_t mRightShiftOut) {
    fbb_.AddElement<int32_t>(30, mRightShiftOut, 0);
  }
  void add_type(int32_t type) {
    fbb_.AddElement<int32_t>(32, type, 0);
  }
  explicit BinarySuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BinarySuperAcmeQuantizedParamBuilder &operator=(const BinarySuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<BinarySuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BinarySuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<BinarySuperAcmeQuantizedParam> CreateBinarySuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t input1Offset = 0,
    int32_t input2Offset = 0,
    int32_t outputOffset = 0,
    int32_t input1Multiplier = 0,
    int32_t input2Multiplier = 0,
    int32_t outputMultiplier = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0,
    int32_t mLeftShiftResult1 = 0,
    int32_t mLeftShiftResult2 = 0,
    int32_t mRightShift1 = 0,
    int32_t mRightShift2 = 0,
    int32_t mLeftShiftOut = 0,
    int32_t mRightShiftOut = 0,
    int32_t type = 0) {
  BinarySuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_type(type);
  builder_.add_mRightShiftOut(mRightShiftOut);
  builder_.add_mLeftShiftOut(mLeftShiftOut);
  builder_.add_mRightShift2(mRightShift2);
  builder_.add_mRightShift1(mRightShift1);
  builder_.add_mLeftShiftResult2(mLeftShiftResult2);
  builder_.add_mLeftShiftResult1(mLeftShiftResult1);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_outputMultiplier(outputMultiplier);
  builder_.add_input2Multiplier(input2Multiplier);
  builder_.add_input1Multiplier(input1Multiplier);
  builder_.add_outputOffset(outputOffset);
  builder_.add_input2Offset(input2Offset);
  builder_.add_input1Offset(input1Offset);
  return builder_.Finish();
}

flatbuffers::Offset<BinarySuperAcmeQuantizedParam> CreateBinarySuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const BinarySuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ScaleSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef ScaleSuperAcmeQuantizedParam TableType;
  int32_t mRightShift;
  std::vector<int32_t> mquantizeMultiplier;
  std::vector<int32_t> mintbias;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  ScaleSuperAcmeQuantizedParamT()
      : mRightShift(0),
        outputActivationMin(0),
        outputActivationMax(0) {
  }
};

struct ScaleSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ScaleSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ScaleSuperAcmeQuantizedParamTypeTable();
  }
  int32_t mRightShift() const {
    return GetField<int32_t>(4, 0);
  }
  const flatbuffers::Vector<int32_t> *mquantizeMultiplier() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(6);
  }
  const flatbuffers::Vector<int32_t> *mintbias() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(8);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(12, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyOffset(verifier, 6) &&
           verifier.VerifyVector(mquantizeMultiplier()) &&
           VerifyOffset(verifier, 8) &&
           verifier.VerifyVector(mintbias()) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           verifier.EndTable();
  }
  ScaleSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(ScaleSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScaleSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct ScaleSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_mRightShift(int32_t mRightShift) {
    fbb_.AddElement<int32_t>(4, mRightShift, 0);
  }
  void add_mquantizeMultiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mquantizeMultiplier) {
    fbb_.AddOffset(6, mquantizeMultiplier);
  }
  void add_mintbias(flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbias) {
    fbb_.AddOffset(8, mintbias);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(10, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(12, outputActivationMax, 0);
  }
  explicit ScaleSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ScaleSuperAcmeQuantizedParamBuilder &operator=(const ScaleSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ScaleSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> CreateScaleSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t mRightShift = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mquantizeMultiplier = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> mintbias = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0) {
  ScaleSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_mintbias(mintbias);
  builder_.add_mquantizeMultiplier(mquantizeMultiplier);
  builder_.add_mRightShift(mRightShift);
  return builder_.Finish();
}

flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> CreateScaleSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ScaleSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MatMulSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef MatMulSuperAcmeQuantizedParam TableType;
  int32_t mquantizeMultiplier;
  int32_t mRightShift;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  int32_t input1Offset;
  int32_t input2Offset;
  int32_t outputOffset;
  int32_t mOffsetSum;
  int32_t mBiasquantizeMultiplier;
  int32_t mBiasShift;
  MatMulSuperAcmeQuantizedParamT()
      : mquantizeMultiplier(0),
        mRightShift(0),
        outputActivationMin(0),
        outputActivationMax(0),
        input1Offset(0),
        input2Offset(0),
        outputOffset(0),
        mOffsetSum(0),
        mBiasquantizeMultiplier(0),
        mBiasShift(0) {
  }
};

struct MatMulSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MatMulSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return MatMulSuperAcmeQuantizedParamTypeTable();
  }
  int32_t mquantizeMultiplier() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t mRightShift() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t input1Offset() const {
    return GetField<int32_t>(12, 0);
  }
  int32_t input2Offset() const {
    return GetField<int32_t>(14, 0);
  }
  int32_t outputOffset() const {
    return GetField<int32_t>(16, 0);
  }
  int32_t mOffsetSum() const {
    return GetField<int32_t>(18, 0);
  }
  int32_t mBiasquantizeMultiplier() const {
    return GetField<int32_t>(20, 0);
  }
  int32_t mBiasShift() const {
    return GetField<int32_t>(22, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           VerifyField<int32_t>(verifier, 14) &&
           VerifyField<int32_t>(verifier, 16) &&
           VerifyField<int32_t>(verifier, 18) &&
           VerifyField<int32_t>(verifier, 20) &&
           VerifyField<int32_t>(verifier, 22) &&
           verifier.EndTable();
  }
  MatMulSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(MatMulSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatMulSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct MatMulSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_mquantizeMultiplier(int32_t mquantizeMultiplier) {
    fbb_.AddElement<int32_t>(4, mquantizeMultiplier, 0);
  }
  void add_mRightShift(int32_t mRightShift) {
    fbb_.AddElement<int32_t>(6, mRightShift, 0);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(8, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(10, outputActivationMax, 0);
  }
  void add_input1Offset(int32_t input1Offset) {
    fbb_.AddElement<int32_t>(12, input1Offset, 0);
  }
  void add_input2Offset(int32_t input2Offset) {
    fbb_.AddElement<int32_t>(14, input2Offset, 0);
  }
  void add_outputOffset(int32_t outputOffset) {
    fbb_.AddElement<int32_t>(16, outputOffset, 0);
  }
  void add_mOffsetSum(int32_t mOffsetSum) {
    fbb_.AddElement<int32_t>(18, mOffsetSum, 0);
  }
  void add_mBiasquantizeMultiplier(int32_t mBiasquantizeMultiplier) {
    fbb_.AddElement<int32_t>(20, mBiasquantizeMultiplier, 0);
  }
  void add_mBiasShift(int32_t mBiasShift) {
    fbb_.AddElement<int32_t>(22, mBiasShift, 0);
  }
  explicit MatMulSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MatMulSuperAcmeQuantizedParamBuilder &operator=(const MatMulSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<MatMulSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> CreateMatMulSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t mquantizeMultiplier = 0,
    int32_t mRightShift = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0,
    int32_t input1Offset = 0,
    int32_t input2Offset = 0,
    int32_t outputOffset = 0,
    int32_t mOffsetSum = 0,
    int32_t mBiasquantizeMultiplier = 0,
    int32_t mBiasShift = 0) {
  MatMulSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_mBiasShift(mBiasShift);
  builder_.add_mBiasquantizeMultiplier(mBiasquantizeMultiplier);
  builder_.add_mOffsetSum(mOffsetSum);
  builder_.add_outputOffset(outputOffset);
  builder_.add_input2Offset(input2Offset);
  builder_.add_input1Offset(input1Offset);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_mRightShift(mRightShift);
  builder_.add_mquantizeMultiplier(mquantizeMultiplier);
  return builder_.Finish();
}

flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> CreateMatMulSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const MatMulSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ArgMaxSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef ArgMaxSuperAcmeQuantizedParam TableType;
  int32_t mouttype;
  float mscale;
  int32_t mzero;
  ArgMaxSuperAcmeQuantizedParamT()
      : mouttype(0),
        mscale(0.0f),
        mzero(0) {
  }
};

struct ArgMaxSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ArgMaxSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ArgMaxSuperAcmeQuantizedParamTypeTable();
  }
  int32_t mouttype() const {
    return GetField<int32_t>(4, 0);
  }
  float mscale() const {
    return GetField<float>(6, 0.0f);
  }
  int32_t mzero() const {
    return GetField<int32_t>(8, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<float>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           verifier.EndTable();
  }
  ArgMaxSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(ArgMaxSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct ArgMaxSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_mouttype(int32_t mouttype) {
    fbb_.AddElement<int32_t>(4, mouttype, 0);
  }
  void add_mscale(float mscale) {
    fbb_.AddElement<float>(6, mscale, 0.0f);
  }
  void add_mzero(int32_t mzero) {
    fbb_.AddElement<int32_t>(8, mzero, 0);
  }
  explicit ArgMaxSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ArgMaxSuperAcmeQuantizedParamBuilder &operator=(const ArgMaxSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> CreateArgMaxSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t mouttype = 0,
    float mscale = 0.0f,
    int32_t mzero = 0) {
  ArgMaxSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_mzero(mzero);
  builder_.add_mscale(mscale);
  builder_.add_mouttype(mouttype);
  return builder_.Finish();
}

flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> CreateArgMaxSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ReductionSuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef ReductionSuperAcmeQuantizedParam TableType;
  int32_t inputZeroPoint;
  int32_t mquantizeMultiplier;
  int32_t mRightShift;
  int32_t outputActivationMin;
  int32_t outputActivationMax;
  int32_t outputOffset;
  ReductionSuperAcmeQuantizedParamT()
      : inputZeroPoint(0),
        mquantizeMultiplier(0),
        mRightShift(0),
        outputActivationMin(0),
        outputActivationMax(0),
        outputOffset(0) {
  }
};

struct ReductionSuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ReductionSuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ReductionSuperAcmeQuantizedParamTypeTable();
  }
  int32_t inputZeroPoint() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t mquantizeMultiplier() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t mRightShift() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t outputActivationMin() const {
    return GetField<int32_t>(10, 0);
  }
  int32_t outputActivationMax() const {
    return GetField<int32_t>(12, 0);
  }
  int32_t outputOffset() const {
    return GetField<int32_t>(14, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           VerifyField<int32_t>(verifier, 12) &&
           VerifyField<int32_t>(verifier, 14) &&
           verifier.EndTable();
  }
  ReductionSuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(ReductionSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReductionSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct ReductionSuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_inputZeroPoint(int32_t inputZeroPoint) {
    fbb_.AddElement<int32_t>(4, inputZeroPoint, 0);
  }
  void add_mquantizeMultiplier(int32_t mquantizeMultiplier) {
    fbb_.AddElement<int32_t>(6, mquantizeMultiplier, 0);
  }
  void add_mRightShift(int32_t mRightShift) {
    fbb_.AddElement<int32_t>(8, mRightShift, 0);
  }
  void add_outputActivationMin(int32_t outputActivationMin) {
    fbb_.AddElement<int32_t>(10, outputActivationMin, 0);
  }
  void add_outputActivationMax(int32_t outputActivationMax) {
    fbb_.AddElement<int32_t>(12, outputActivationMax, 0);
  }
  void add_outputOffset(int32_t outputOffset) {
    fbb_.AddElement<int32_t>(14, outputOffset, 0);
  }
  explicit ReductionSuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ReductionSuperAcmeQuantizedParamBuilder &operator=(const ReductionSuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ReductionSuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> CreateReductionSuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t inputZeroPoint = 0,
    int32_t mquantizeMultiplier = 0,
    int32_t mRightShift = 0,
    int32_t outputActivationMin = 0,
    int32_t outputActivationMax = 0,
    int32_t outputOffset = 0) {
  ReductionSuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_outputOffset(outputOffset);
  builder_.add_outputActivationMax(outputActivationMax);
  builder_.add_outputActivationMin(outputActivationMin);
  builder_.add_mRightShift(mRightShift);
  builder_.add_mquantizeMultiplier(mquantizeMultiplier);
  builder_.add_inputZeroPoint(inputZeroPoint);
  return builder_.Finish();
}

flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> CreateReductionSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ReductionSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct Relu6SuperAcmeQuantizedParamT : public flatbuffers::NativeTable {
  typedef Relu6SuperAcmeQuantizedParam TableType;
  int32_t thresMin;
  int32_t thresMax;
  Relu6SuperAcmeQuantizedParamT()
      : thresMin(0),
        thresMax(0) {
  }
};

struct Relu6SuperAcmeQuantizedParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef Relu6SuperAcmeQuantizedParamT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Relu6SuperAcmeQuantizedParamTypeTable();
  }
  int32_t thresMin() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t thresMax() const {
    return GetField<int32_t>(6, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           verifier.EndTable();
  }
  Relu6SuperAcmeQuantizedParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(Relu6SuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Relu6SuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct Relu6SuperAcmeQuantizedParamBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_thresMin(int32_t thresMin) {
    fbb_.AddElement<int32_t>(4, thresMin, 0);
  }
  void add_thresMax(int32_t thresMax) {
    fbb_.AddElement<int32_t>(6, thresMax, 0);
  }
  explicit Relu6SuperAcmeQuantizedParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  Relu6SuperAcmeQuantizedParamBuilder &operator=(const Relu6SuperAcmeQuantizedParamBuilder &);
  flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Relu6SuperAcmeQuantizedParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> CreateRelu6SuperAcmeQuantizedParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t thresMin = 0,
    int32_t thresMax = 0) {
  Relu6SuperAcmeQuantizedParamBuilder builder_(_fbb);
  builder_.add_thresMax(thresMax);
  builder_.add_thresMin(thresMin);
  return builder_.Finish();
}

flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> CreateRelu6SuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const Relu6SuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline Conv2dSuperAcmeQuantizedParamT *Conv2dSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new Conv2dSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Conv2dSuperAcmeQuantizedParam::UnPackTo(Conv2dSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = mquantizeMultiplier(); if (_e) { _o->mquantizeMultiplier.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mquantizeMultiplier[_i] = _e->Get(_i); } } };
  { auto _e = mRightShift(); if (_e) { _o->mRightShift.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mRightShift[_i] = _e->Get(_i); } } };
  { auto _e = mintbias(); if (_e) { _o->mintbias.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mintbias[_i] = _e->Get(_i); } } };
  { auto _e = mmode(); _o->mmode = _e; };
  { auto _e = weightType(); _o->weightType = _e; };
}

inline flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> Conv2dSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2dSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateConv2dSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Conv2dSuperAcmeQuantizedParam> CreateConv2dSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const Conv2dSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2dSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _mquantizeMultiplier = _o->mquantizeMultiplier.size() ? _fbb.CreateVector(_o->mquantizeMultiplier) : 0;
  auto _mRightShift = _o->mRightShift.size() ? _fbb.CreateVector(_o->mRightShift) : 0;
  auto _mintbias = _o->mintbias.size() ? _fbb.CreateVector(_o->mintbias) : 0;
  auto _mmode = _o->mmode;
  auto _weightType = _o->weightType;
  return MNN::CreateConv2dSuperAcmeQuantizedParam(
      _fbb,
      _mquantizeMultiplier,
      _mRightShift,
      _mintbias,
      _mmode,
      _weightType);
}

inline EltwiseSuperAcmeQuantizedParamT *EltwiseSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new EltwiseSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void EltwiseSuperAcmeQuantizedParam::UnPackTo(EltwiseSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = input1Offset(); _o->input1Offset = _e; };
  { auto _e = input2Offset(); _o->input2Offset = _e; };
  { auto _e = outputOffset(); _o->outputOffset = _e; };
  { auto _e = input1Multiplier(); _o->input1Multiplier = _e; };
  { auto _e = input2Multiplier(); _o->input2Multiplier = _e; };
  { auto _e = outputMultiplier(); _o->outputMultiplier = _e; };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
  { auto _e = mLeftShiftResult1(); _o->mLeftShiftResult1 = _e; };
  { auto _e = mLeftShiftResult2(); _o->mLeftShiftResult2 = _e; };
  { auto _e = mRightShift1(); _o->mRightShift1 = _e; };
  { auto _e = mRightShift2(); _o->mRightShift2 = _e; };
  { auto _e = mLeftShiftOut(); _o->mLeftShiftOut = _e; };
  { auto _e = mRightShiftOut(); _o->mRightShiftOut = _e; };
  { auto _e = mode(); _o->mode = _e; };
}

inline flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> EltwiseSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EltwiseSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateEltwiseSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<EltwiseSuperAcmeQuantizedParam> CreateEltwiseSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const EltwiseSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EltwiseSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _input1Offset = _o->input1Offset;
  auto _input2Offset = _o->input2Offset;
  auto _outputOffset = _o->outputOffset;
  auto _input1Multiplier = _o->input1Multiplier;
  auto _input2Multiplier = _o->input2Multiplier;
  auto _outputMultiplier = _o->outputMultiplier;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  auto _mLeftShiftResult1 = _o->mLeftShiftResult1;
  auto _mLeftShiftResult2 = _o->mLeftShiftResult2;
  auto _mRightShift1 = _o->mRightShift1;
  auto _mRightShift2 = _o->mRightShift2;
  auto _mLeftShiftOut = _o->mLeftShiftOut;
  auto _mRightShiftOut = _o->mRightShiftOut;
  auto _mode = _o->mode;
  return MNN::CreateEltwiseSuperAcmeQuantizedParam(
      _fbb,
      _input1Offset,
      _input2Offset,
      _outputOffset,
      _input1Multiplier,
      _input2Multiplier,
      _outputMultiplier,
      _outputActivationMin,
      _outputActivationMax,
      _mLeftShiftResult1,
      _mLeftShiftResult2,
      _mRightShift1,
      _mRightShift2,
      _mLeftShiftOut,
      _mRightShiftOut,
      _mode);
}

inline PoolingSuperAcmeQuantizedParamT *PoolingSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PoolingSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PoolingSuperAcmeQuantizedParam::UnPackTo(PoolingSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = needscale(); _o->needscale = _e; };
  { auto _e = inputOffset(); _o->inputOffset = _e; };
  { auto _e = outputOffset(); _o->outputOffset = _e; };
  { auto _e = outputMultiplier(); _o->outputMultiplier = _e; };
  { auto _e = outputShift(); _o->outputShift = _e; };
}

inline flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> PoolingSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PoolingSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePoolingSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PoolingSuperAcmeQuantizedParam> CreatePoolingSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const PoolingSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PoolingSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _needscale = _o->needscale;
  auto _inputOffset = _o->inputOffset;
  auto _outputOffset = _o->outputOffset;
  auto _outputMultiplier = _o->outputMultiplier;
  auto _outputShift = _o->outputShift;
  return MNN::CreatePoolingSuperAcmeQuantizedParam(
      _fbb,
      _needscale,
      _inputOffset,
      _outputOffset,
      _outputMultiplier,
      _outputShift);
}

inline ReluSuperAcmeQuantizedParamT *ReluSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ReluSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ReluSuperAcmeQuantizedParam::UnPackTo(ReluSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = inputZero(); _o->inputZero = _e; };
  { auto _e = outputZero(); _o->outputZero = _e; };
  { auto _e = inputScale(); _o->inputScale = _e; };
  { auto _e = outputScale(); _o->outputScale = _e; };
}

inline flatbuffers::Offset<ReluSuperAcmeQuantizedParam> ReluSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReluSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateReluSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ReluSuperAcmeQuantizedParam> CreateReluSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ReluSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReluSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _inputZero = _o->inputZero;
  auto _outputZero = _o->outputZero;
  auto _inputScale = _o->inputScale;
  auto _outputScale = _o->outputScale;
  return MNN::CreateReluSuperAcmeQuantizedParam(
      _fbb,
      _inputZero,
      _outputZero,
      _inputScale,
      _outputScale);
}

inline PReluSuperAcmeQuantizedParamT *PReluSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PReluSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PReluSuperAcmeQuantizedParam::UnPackTo(PReluSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = inputZero(); _o->inputZero = _e; };
  { auto _e = outputZero(); _o->outputZero = _e; };
  { auto _e = slope_q(); if (_e) { _o->slope_q.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slope_q[_i] = _e->Get(_i); } } };
  { auto _e = mRightShiftQ(); if (_e) { _o->mRightShiftQ.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mRightShiftQ[_i] = _e->Get(_i); } } };
  { auto _e = mRightShiftQ_(); _o->mRightShiftQ_ = _e; };
  { auto _e = slope_p(); if (_e) { _o->slope_p.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->slope_p[_i] = _e->Get(_i); } } };
  { auto _e = mRightShiftP(); if (_e) { _o->mRightShiftP.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mRightShiftP[_i] = _e->Get(_i); } } };
  { auto _e = mRightShiftP_(); _o->mRightShiftP_ = _e; };
  { auto _e = mintbiasQ(); if (_e) { _o->mintbiasQ.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mintbiasQ[_i] = _e->Get(_i); } } };
  { auto _e = mintbiasP(); if (_e) { _o->mintbiasP.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mintbiasP[_i] = _e->Get(_i); } } };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
}

inline flatbuffers::Offset<PReluSuperAcmeQuantizedParam> PReluSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PReluSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePReluSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PReluSuperAcmeQuantizedParam> CreatePReluSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const PReluSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PReluSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _inputZero = _o->inputZero;
  auto _outputZero = _o->outputZero;
  auto _slope_q = _o->slope_q.size() ? _fbb.CreateVector(_o->slope_q) : 0;
  auto _mRightShiftQ = _o->mRightShiftQ.size() ? _fbb.CreateVector(_o->mRightShiftQ) : 0;
  auto _mRightShiftQ_ = _o->mRightShiftQ_;
  auto _slope_p = _o->slope_p.size() ? _fbb.CreateVector(_o->slope_p) : 0;
  auto _mRightShiftP = _o->mRightShiftP.size() ? _fbb.CreateVector(_o->mRightShiftP) : 0;
  auto _mRightShiftP_ = _o->mRightShiftP_;
  auto _mintbiasQ = _o->mintbiasQ.size() ? _fbb.CreateVector(_o->mintbiasQ) : 0;
  auto _mintbiasP = _o->mintbiasP.size() ? _fbb.CreateVector(_o->mintbiasP) : 0;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  return MNN::CreatePReluSuperAcmeQuantizedParam(
      _fbb,
      _inputZero,
      _outputZero,
      _slope_q,
      _mRightShiftQ,
      _mRightShiftQ_,
      _slope_p,
      _mRightShiftP,
      _mRightShiftP_,
      _mintbiasQ,
      _mintbiasP,
      _outputActivationMin,
      _outputActivationMax);
}

inline LutSuperAcmeQuantizedParamT *LutSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new LutSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void LutSuperAcmeQuantizedParam::UnPackTo(LutSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = lutFlag(); _o->lutFlag = _e; };
  { auto _e = lutTbl(); if (_e) { _o->lutTbl.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lutTbl[_i] = _e->Get(_i); } } };
  { auto _e = inputZero(); _o->inputZero = _e; };
  { auto _e = outputZero(); _o->outputZero = _e; };
  { auto _e = inputScale(); _o->inputScale = _e; };
  { auto _e = outputScale(); _o->outputScale = _e; };
}

inline flatbuffers::Offset<LutSuperAcmeQuantizedParam> LutSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LutSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLutSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LutSuperAcmeQuantizedParam> CreateLutSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const LutSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LutSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _lutFlag = _o->lutFlag;
  auto _lutTbl = _o->lutTbl.size() ? _fbb.CreateVector(_o->lutTbl) : 0;
  auto _inputZero = _o->inputZero;
  auto _outputZero = _o->outputZero;
  auto _inputScale = _o->inputScale;
  auto _outputScale = _o->outputScale;
  return MNN::CreateLutSuperAcmeQuantizedParam(
      _fbb,
      _lutFlag,
      _lutTbl,
      _inputZero,
      _outputZero,
      _inputScale,
      _outputScale);
}

inline InterpSuperAcmeQuantizedParamT *InterpSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new InterpSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void InterpSuperAcmeQuantizedParam::UnPackTo(InterpSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = mode(); _o->mode = _e; };
  { auto _e = xPositions(); if (_e) { _o->xPositions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->xPositions[_i] = _e->Get(_i); } } };
  { auto _e = yPositions(); if (_e) { _o->yPositions.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->yPositions[_i] = _e->Get(_i); } } };
  { auto _e = xFactors(); if (_e) { _o->xFactors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->xFactors[_i] = _e->Get(_i); } } };
  { auto _e = yFactors(); if (_e) { _o->yFactors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->yFactors[_i] = _e->Get(_i); } } };
  { auto _e = unifiedFactorShift(); _o->unifiedFactorShift = _e; };
  { auto _e = clampMin(); _o->clampMin = _e; };
  { auto _e = clampMax(); _o->clampMax = _e; };
}

inline flatbuffers::Offset<InterpSuperAcmeQuantizedParam> InterpSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InterpSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateInterpSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<InterpSuperAcmeQuantizedParam> CreateInterpSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const InterpSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InterpSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _mode = _o->mode;
  auto _xPositions = _o->xPositions.size() ? _fbb.CreateVector(_o->xPositions) : 0;
  auto _yPositions = _o->yPositions.size() ? _fbb.CreateVector(_o->yPositions) : 0;
  auto _xFactors = _o->xFactors.size() ? _fbb.CreateVector(_o->xFactors) : 0;
  auto _yFactors = _o->yFactors.size() ? _fbb.CreateVector(_o->yFactors) : 0;
  auto _unifiedFactorShift = _o->unifiedFactorShift;
  auto _clampMin = _o->clampMin;
  auto _clampMax = _o->clampMax;
  return MNN::CreateInterpSuperAcmeQuantizedParam(
      _fbb,
      _mode,
      _xPositions,
      _yPositions,
      _xFactors,
      _yFactors,
      _unifiedFactorShift,
      _clampMin,
      _clampMax);
}

inline BinarySuperAcmeQuantizedParamT *BinarySuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new BinarySuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void BinarySuperAcmeQuantizedParam::UnPackTo(BinarySuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = input1Offset(); _o->input1Offset = _e; };
  { auto _e = input2Offset(); _o->input2Offset = _e; };
  { auto _e = outputOffset(); _o->outputOffset = _e; };
  { auto _e = input1Multiplier(); _o->input1Multiplier = _e; };
  { auto _e = input2Multiplier(); _o->input2Multiplier = _e; };
  { auto _e = outputMultiplier(); _o->outputMultiplier = _e; };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
  { auto _e = mLeftShiftResult1(); _o->mLeftShiftResult1 = _e; };
  { auto _e = mLeftShiftResult2(); _o->mLeftShiftResult2 = _e; };
  { auto _e = mRightShift1(); _o->mRightShift1 = _e; };
  { auto _e = mRightShift2(); _o->mRightShift2 = _e; };
  { auto _e = mLeftShiftOut(); _o->mLeftShiftOut = _e; };
  { auto _e = mRightShiftOut(); _o->mRightShiftOut = _e; };
  { auto _e = type(); _o->type = _e; };
}

inline flatbuffers::Offset<BinarySuperAcmeQuantizedParam> BinarySuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BinarySuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateBinarySuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<BinarySuperAcmeQuantizedParam> CreateBinarySuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const BinarySuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BinarySuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _input1Offset = _o->input1Offset;
  auto _input2Offset = _o->input2Offset;
  auto _outputOffset = _o->outputOffset;
  auto _input1Multiplier = _o->input1Multiplier;
  auto _input2Multiplier = _o->input2Multiplier;
  auto _outputMultiplier = _o->outputMultiplier;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  auto _mLeftShiftResult1 = _o->mLeftShiftResult1;
  auto _mLeftShiftResult2 = _o->mLeftShiftResult2;
  auto _mRightShift1 = _o->mRightShift1;
  auto _mRightShift2 = _o->mRightShift2;
  auto _mLeftShiftOut = _o->mLeftShiftOut;
  auto _mRightShiftOut = _o->mRightShiftOut;
  auto _type = _o->type;
  return MNN::CreateBinarySuperAcmeQuantizedParam(
      _fbb,
      _input1Offset,
      _input2Offset,
      _outputOffset,
      _input1Multiplier,
      _input2Multiplier,
      _outputMultiplier,
      _outputActivationMin,
      _outputActivationMax,
      _mLeftShiftResult1,
      _mLeftShiftResult2,
      _mRightShift1,
      _mRightShift2,
      _mLeftShiftOut,
      _mRightShiftOut,
      _type);
}

inline ScaleSuperAcmeQuantizedParamT *ScaleSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ScaleSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ScaleSuperAcmeQuantizedParam::UnPackTo(ScaleSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = mRightShift(); _o->mRightShift = _e; };
  { auto _e = mquantizeMultiplier(); if (_e) { _o->mquantizeMultiplier.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mquantizeMultiplier[_i] = _e->Get(_i); } } };
  { auto _e = mintbias(); if (_e) { _o->mintbias.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mintbias[_i] = _e->Get(_i); } } };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
}

inline flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> ScaleSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScaleSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateScaleSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ScaleSuperAcmeQuantizedParam> CreateScaleSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ScaleSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScaleSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _mRightShift = _o->mRightShift;
  auto _mquantizeMultiplier = _o->mquantizeMultiplier.size() ? _fbb.CreateVector(_o->mquantizeMultiplier) : 0;
  auto _mintbias = _o->mintbias.size() ? _fbb.CreateVector(_o->mintbias) : 0;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  return MNN::CreateScaleSuperAcmeQuantizedParam(
      _fbb,
      _mRightShift,
      _mquantizeMultiplier,
      _mintbias,
      _outputActivationMin,
      _outputActivationMax);
}

inline MatMulSuperAcmeQuantizedParamT *MatMulSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new MatMulSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void MatMulSuperAcmeQuantizedParam::UnPackTo(MatMulSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = mquantizeMultiplier(); _o->mquantizeMultiplier = _e; };
  { auto _e = mRightShift(); _o->mRightShift = _e; };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
  { auto _e = input1Offset(); _o->input1Offset = _e; };
  { auto _e = input2Offset(); _o->input2Offset = _e; };
  { auto _e = outputOffset(); _o->outputOffset = _e; };
  { auto _e = mOffsetSum(); _o->mOffsetSum = _e; };
  { auto _e = mBiasquantizeMultiplier(); _o->mBiasquantizeMultiplier = _e; };
  { auto _e = mBiasShift(); _o->mBiasShift = _e; };
}

inline flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> MatMulSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatMulSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateMatMulSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<MatMulSuperAcmeQuantizedParam> CreateMatMulSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const MatMulSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatMulSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _mquantizeMultiplier = _o->mquantizeMultiplier;
  auto _mRightShift = _o->mRightShift;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  auto _input1Offset = _o->input1Offset;
  auto _input2Offset = _o->input2Offset;
  auto _outputOffset = _o->outputOffset;
  auto _mOffsetSum = _o->mOffsetSum;
  auto _mBiasquantizeMultiplier = _o->mBiasquantizeMultiplier;
  auto _mBiasShift = _o->mBiasShift;
  return MNN::CreateMatMulSuperAcmeQuantizedParam(
      _fbb,
      _mquantizeMultiplier,
      _mRightShift,
      _outputActivationMin,
      _outputActivationMax,
      _input1Offset,
      _input2Offset,
      _outputOffset,
      _mOffsetSum,
      _mBiasquantizeMultiplier,
      _mBiasShift);
}

inline ArgMaxSuperAcmeQuantizedParamT *ArgMaxSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ArgMaxSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ArgMaxSuperAcmeQuantizedParam::UnPackTo(ArgMaxSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = mouttype(); _o->mouttype = _e; };
  { auto _e = mscale(); _o->mscale = _e; };
  { auto _e = mzero(); _o->mzero = _e; };
}

inline flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> ArgMaxSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateArgMaxSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ArgMaxSuperAcmeQuantizedParam> CreateArgMaxSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _mouttype = _o->mouttype;
  auto _mscale = _o->mscale;
  auto _mzero = _o->mzero;
  return MNN::CreateArgMaxSuperAcmeQuantizedParam(
      _fbb,
      _mouttype,
      _mscale,
      _mzero);
}

inline ReductionSuperAcmeQuantizedParamT *ReductionSuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ReductionSuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ReductionSuperAcmeQuantizedParam::UnPackTo(ReductionSuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = inputZeroPoint(); _o->inputZeroPoint = _e; };
  { auto _e = mquantizeMultiplier(); _o->mquantizeMultiplier = _e; };
  { auto _e = mRightShift(); _o->mRightShift = _e; };
  { auto _e = outputActivationMin(); _o->outputActivationMin = _e; };
  { auto _e = outputActivationMax(); _o->outputActivationMax = _e; };
  { auto _e = outputOffset(); _o->outputOffset = _e; };
}

inline flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> ReductionSuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReductionSuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateReductionSuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ReductionSuperAcmeQuantizedParam> CreateReductionSuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const ReductionSuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReductionSuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _inputZeroPoint = _o->inputZeroPoint;
  auto _mquantizeMultiplier = _o->mquantizeMultiplier;
  auto _mRightShift = _o->mRightShift;
  auto _outputActivationMin = _o->outputActivationMin;
  auto _outputActivationMax = _o->outputActivationMax;
  auto _outputOffset = _o->outputOffset;
  return MNN::CreateReductionSuperAcmeQuantizedParam(
      _fbb,
      _inputZeroPoint,
      _mquantizeMultiplier,
      _mRightShift,
      _outputActivationMin,
      _outputActivationMax,
      _outputOffset);
}

inline Relu6SuperAcmeQuantizedParamT *Relu6SuperAcmeQuantizedParam::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new Relu6SuperAcmeQuantizedParamT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void Relu6SuperAcmeQuantizedParam::UnPackTo(Relu6SuperAcmeQuantizedParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = thresMin(); _o->thresMin = _e; };
  { auto _e = thresMax(); _o->thresMax = _e; };
}

inline flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> Relu6SuperAcmeQuantizedParam::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Relu6SuperAcmeQuantizedParamT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateRelu6SuperAcmeQuantizedParam(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<Relu6SuperAcmeQuantizedParam> CreateRelu6SuperAcmeQuantizedParam(flatbuffers::FlatBufferBuilder &_fbb, const Relu6SuperAcmeQuantizedParamT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Relu6SuperAcmeQuantizedParamT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _thresMin = _o->thresMin;
  auto _thresMax = _o->thresMax;
  return MNN::CreateRelu6SuperAcmeQuantizedParam(
      _fbb,
      _thresMin,
      _thresMax);
}

inline const flatbuffers::TypeTable *Conv2dSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, 0 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    DataTypeTypeTable
  };
  static const char * const names[] = {
    "mquantizeMultiplier",
    "mRightShift",
    "mintbias",
    "mmode",
    "weightType"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *EltwiseSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "input1Offset",
    "input2Offset",
    "outputOffset",
    "input1Multiplier",
    "input2Multiplier",
    "outputMultiplier",
    "outputActivationMin",
    "outputActivationMax",
    "mLeftShiftResult1",
    "mLeftShiftResult2",
    "mRightShift1",
    "mRightShift2",
    "mLeftShiftOut",
    "mRightShiftOut",
    "mode"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 15, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *PoolingSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_BOOL, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "needscale",
    "inputOffset",
    "outputOffset",
    "outputMultiplier",
    "outputShift"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 5, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ReluSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "inputZero",
    "outputZero",
    "inputScale",
    "outputScale"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 4, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *PReluSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "inputZero",
    "outputZero",
    "slope_q",
    "mRightShiftQ",
    "mRightShiftQ_",
    "slope_p",
    "mRightShiftP",
    "mRightShiftP_",
    "mintbiasQ",
    "mintbiasP",
    "outputActivationMin",
    "outputActivationMax"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *LutSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_BOOL, 0, -1 },
    { flatbuffers::ET_CHAR, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_DOUBLE, 0, -1 },
    { flatbuffers::ET_DOUBLE, 0, -1 }
  };
  static const char * const names[] = {
    "lutFlag",
    "lutTbl",
    "inputZero",
    "outputZero",
    "inputScale",
    "outputScale"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *InterpSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_CHAR, 0, -1 },
    { flatbuffers::ET_CHAR, 0, -1 }
  };
  static const char * const names[] = {
    "mode",
    "xPositions",
    "yPositions",
    "xFactors",
    "yFactors",
    "unifiedFactorShift",
    "clampMin",
    "clampMax"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 8, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *BinarySuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "input1Offset",
    "input2Offset",
    "outputOffset",
    "input1Multiplier",
    "input2Multiplier",
    "outputMultiplier",
    "outputActivationMin",
    "outputActivationMax",
    "mLeftShiftResult1",
    "mLeftShiftResult2",
    "mRightShift1",
    "mRightShift2",
    "mLeftShiftOut",
    "mRightShiftOut",
    "type"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 15, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ScaleSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 1, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "mRightShift",
    "mquantizeMultiplier",
    "mintbias",
    "outputActivationMin",
    "outputActivationMax"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 5, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *MatMulSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "mquantizeMultiplier",
    "mRightShift",
    "outputActivationMin",
    "outputActivationMax",
    "input1Offset",
    "input2Offset",
    "outputOffset",
    "mOffsetSum",
    "mBiasquantizeMultiplier",
    "mBiasShift"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 10, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ArgMaxSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_FLOAT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "mouttype",
    "mscale",
    "mzero"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *ReductionSuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "inputZeroPoint",
    "mquantizeMultiplier",
    "mRightShift",
    "outputActivationMin",
    "outputActivationMax",
    "outputOffset"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 6, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

inline const flatbuffers::TypeTable *Relu6SuperAcmeQuantizedParamTypeTable() {
  static const flatbuffers::TypeCode type_codes[] = {
    { flatbuffers::ET_INT, 0, -1 },
    { flatbuffers::ET_INT, 0, -1 }
  };
  static const char * const names[] = {
    "thresMin",
    "thresMax"
  };
  static const flatbuffers::TypeTable tt = {
    flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
  };
  return &tt;
}

}  // namespace MNN

#endif  // FLATBUFFERS_GENERATED_SUPERACMEQUANTIZEOP_MNN_H_
