netron/source/megengine-schema.js

export const mgb = {};

mgb.serialization = mgb.serialization || {};

mgb.serialization.fbs = mgb.serialization.fbs || {};

mgb.serialization.fbs.DTypeEnum = {
    Float32: 0, '0': 'Float32',
    Uint8: 1, '1': 'Uint8',
    Int8: 2, '2': 'Int8',
    Int16: 3, '3': 'Int16',
    Int32: 4, '4': 'Int32',
    IntB1: 5, '5': 'IntB1',
    IntB2: 6, '6': 'IntB2',
    IntB4: 7, '7': 'IntB4',
    Byte: 8, '8': 'Byte',
    Float16: 9, '9': 'Float16',
    UintB4: 10, '10': 'UintB4',
    Quantized8Asymm: 11, '11': 'Quantized8Asymm',
    QuantizedS32: 12, '12': 'QuantizedS32',
    QuantizedS8: 13, '13': 'QuantizedS8',
    Quantized4Asymm: 14, '14': 'Quantized4Asymm',
    QuantizedS4: 15, '15': 'QuantizedS4',
    QuantizedS16: 16, '16': 'QuantizedS16',
    BFloat16: 17, '17': 'BFloat16',
    Bool: 18, '18': 'Bool',
    Uint16: 19, '19': 'Uint16',
    QuantizedS1: 20, '20': 'QuantizedS1'
};

mgb.serialization.fbs.LinearQuantizationParam = class LinearQuantizationParam {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.LinearQuantizationParam();
        $.scale = reader.float32_(position, 4, 0);
        $.zero_point = reader.uint8_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.DTypeParam = class {

    static decode(reader, position, type) {
        switch (type) {
            case 1: return mgb.serialization.fbs.LinearQuantizationParam.decode(reader, position);
            default: return undefined;
        }
    }
};

mgb.serialization.fbs.DType = class DType {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.DType();
        $.type = reader.int8_(position, 4, 0);
        $.param = reader.union(position, 6, mgb.serialization.fbs.DTypeParam);
        return $;
    }
};

mgb.serialization = mgb.serialization || {};

mgb.serialization.fbs = mgb.serialization.fbs || {};

mgb.serialization.fbs.param = mgb.serialization.fbs.param || {};

mgb.serialization.fbs.param.ArgsortOrder = {
    ASCENDING: 0, '0': 'ASCENDING',
    DESCENDING: 1, '1': 'DESCENDING'
};

mgb.serialization.fbs.param.BNFwdMode = {
    TRAINING: 0, '0': 'TRAINING',
    INFERENCE: 1, '1': 'INFERENCE'
};

mgb.serialization.fbs.param.BNParamDim = {
    DIM_11HW: 0, '0': 'DIM_11HW',
    DIM_1CHW: 1, '1': 'DIM_1CHW',
    DIM_1C11: 2, '2': 'DIM_1C11',
    DIM_111C: 3, '3': 'DIM_111C'
};

mgb.serialization.fbs.param.CondTakeMode = {
    EQ: 0, '0': 'EQ',
    NEQ: 1, '1': 'NEQ',
    LT: 2, '2': 'LT',
    LEQ: 3, '3': 'LEQ',
    GT: 4, '4': 'GT',
    GEQ: 5, '5': 'GEQ'
};

mgb.serialization.fbs.param.Conv3DBiasNonlineMode = {
    IDENTITY: 0, '0': 'IDENTITY',
    RELU: 1, '1': 'RELU',
    SIGMOID: 2, '2': 'SIGMOID'
};

mgb.serialization.fbs.param.ConvBiasV0NonlineMode = {
    IDENTITY: 0, '0': 'IDENTITY',
    RELU: 1, '1': 'RELU',
    SIGMOID: 2, '2': 'SIGMOID',
    H_SWISH: 3, '3': 'H_SWISH'
};

mgb.serialization.fbs.param.ConvPoolingMethod = {
    WITH_TEXTURE_OBJ: 0, '0': 'WITH_TEXTURE_OBJ',
    WITH_SHARED_MEM: 1, '1': 'WITH_SHARED_MEM'
};

mgb.serialization.fbs.param.ConvPoolingNonlineMode = {
    IDENTITY: 0, '0': 'IDENTITY',
    RELU: 1, '1': 'RELU',
    SIGMOID: 2, '2': 'SIGMOID'
};

mgb.serialization.fbs.param.ConvPoolingPoolMode = {
    AVERAGE: 0, '0': 'AVERAGE',
    MAX_: 1, '1': 'MAX_'
};

mgb.serialization.fbs.param.ConvolutionFormat = {
    NCHW: 0, '0': 'NCHW',
    NHWC: 1, '1': 'NHWC',
    NHWCD4: 2, '2': 'NHWCD4',
    NCHW4: 3, '3': 'NCHW4',
    NCHW8: 4, '4': 'NCHW8',
    NCHW32: 5, '5': 'NCHW32',
    NCHW88: 6, '6': 'NCHW88',
    NCHW44: 7, '7': 'NCHW44',
    NCHW44_DOT: 8, '8': 'NCHW44_DOT',
    NCHW4_NCHW32: 9, '9': 'NCHW4_NCHW32',
    NCHW32_NCHW4: 10, '10': 'NCHW32_NCHW4',
    NCHW4_NCHW: 11, '11': 'NCHW4_NCHW',
    NHWC_NCHW: 12, '12': 'NHWC_NCHW',
    NHWC_NCHW4_IC_SMALL: 13, '13': 'NHWC_NCHW4_IC_SMALL',
    NCHW_NCHW4_IC_SMALL: 14, '14': 'NCHW_NCHW4_IC_SMALL',
    CHWN4: 15, '15': 'CHWN4',
    NCHW64: 16, '16': 'NCHW64',
    NCHW4_NHWC: 17, '17': 'NCHW4_NHWC'
};

mgb.serialization.fbs.param.Convolution3DDataType = {
    FLOAT: 0, '0': 'FLOAT',
    FLOAT_IO16xC32: 1, '1': 'FLOAT_IO16xC32'
};

mgb.serialization.fbs.param.Convolution3DFormat = {
    NCDHW: 0, '0': 'NCDHW',
    NDHWC: 1, '1': 'NDHWC'
};

mgb.serialization.fbs.param.Convolution3DMode = {
    CROSS_CORRELATION: 0, '0': 'CROSS_CORRELATION',
    CONVOLUTION: 1, '1': 'CONVOLUTION'
};

mgb.serialization.fbs.param.Convolution3DSparse = {
    DENSE: 0, '0': 'DENSE',
    GROUP: 1, '1': 'GROUP'
};

mgb.serialization.fbs.param.ConvolutionV0DataType = {
    FLOAT: 0, '0': 'FLOAT',
    INT8x8x16: 1, '1': 'INT8x8x16',
    INT8x8x32: 2, '2': 'INT8x8x32',
    FLOAT_IO16xC32: 3, '3': 'FLOAT_IO16xC32',
    QUINT8x8x32: 4, '4': 'QUINT8x8x32',
    INT8x8xX: 5, '5': 'INT8x8xX',
    QUINT4x4x32: 6, '6': 'QUINT4x4x32'
};

mgb.serialization.fbs.param.ConvolutionV0Format = {
    NCHW: 0, '0': 'NCHW',
    NHWC: 1, '1': 'NHWC',
    NHWCD4: 2, '2': 'NHWCD4',
    NCHW4: 3, '3': 'NCHW4',
    NCHW8: 4, '4': 'NCHW8',
    NCHW32: 5, '5': 'NCHW32',
    NCHW88: 6, '6': 'NCHW88',
    NCHW44: 7, '7': 'NCHW44',
    NCHW44_DOT: 8, '8': 'NCHW44_DOT',
    NCHW_WINOGRAD: 9, '9': 'NCHW_WINOGRAD',
    NCHW88_WINOGRAD: 10, '10': 'NCHW88_WINOGRAD',
    NCHW44_WINOGRAD: 11, '11': 'NCHW44_WINOGRAD',
    NCHW4_NCHW32: 12, '12': 'NCHW4_NCHW32',
    NCHW32_NCHW4: 13, '13': 'NCHW32_NCHW4',
    NCHW4_NCHW: 14, '14': 'NCHW4_NCHW',
    NHWC_NCHW: 15, '15': 'NHWC_NCHW',
    NHWC_NCHW4_IC_SMALL: 16, '16': 'NHWC_NCHW4_IC_SMALL',
    NCHW_NCHW4_IC_SMALL: 17, '17': 'NCHW_NCHW4_IC_SMALL',
    CHWN4: 18, '18': 'CHWN4',
    NCHW4_NHWC: 19, '19': 'NCHW4_NHWC'
};

mgb.serialization.fbs.param.ConvolutionV0Mode = {
    CROSS_CORRELATION: 0, '0': 'CROSS_CORRELATION',
    CONVOLUTION: 1, '1': 'CONVOLUTION'
};

mgb.serialization.fbs.param.ConvolutionV0Sparse = {
    DENSE: 0, '0': 'DENSE',
    GROUP: 1, '1': 'GROUP'
};

mgb.serialization.fbs.param.ConvolutionV1ComputeMode = {
    DEFAULT: 0, '0': 'DEFAULT',
    FLOAT32: 1, '1': 'FLOAT32'
};

mgb.serialization.fbs.param.CvtColorMode = {
    RGB2GRAY: 0, '0': 'RGB2GRAY',
    RGB2YUV: 1, '1': 'RGB2YUV',
    YUV2RGB: 2, '2': 'YUV2RGB',
    GRAY2RGB: 3, '3': 'GRAY2RGB',
    RGBA2RGB: 4, '4': 'RGBA2RGB',
    RGBA2BGR: 5, '5': 'RGBA2BGR',
    RGBA2GRAY: 6, '6': 'RGBA2GRAY',
    RGB2BGR: 7, '7': 'RGB2BGR',
    BGR2GRAY: 8, '8': 'BGR2GRAY',
    BGR2RGB: 9, '9': 'BGR2RGB',
    YUV2GRAY_NV21: 10, '10': 'YUV2GRAY_NV21',
    YUV2RGB_NV21: 11, '11': 'YUV2RGB_NV21',
    YUV2BGR_NV21: 12, '12': 'YUV2BGR_NV21',
    YUV2GRAY_NV12: 13, '13': 'YUV2GRAY_NV12',
    YUV2RGB_NV12: 14, '14': 'YUV2RGB_NV12',
    YUV2BGR_NV12: 15, '15': 'YUV2BGR_NV12',
    YUV2GRAY_YV12: 16, '16': 'YUV2GRAY_YV12',
    YUV2RGB_YV12: 17, '17': 'YUV2RGB_YV12',
    YUV2BGR_YV12: 18, '18': 'YUV2BGR_YV12',
    YUV2GRAY_YU12: 19, '19': 'YUV2GRAY_YU12',
    YUV2RGB_YU12: 20, '20': 'YUV2RGB_YU12',
    YUV2BGR_YU12: 21, '21': 'YUV2BGR_YU12',
    YCrCb2RGB: 22, '22': 'YCrCb2RGB',
    YCrCb2BGR: 23, '23': 'YCrCb2BGR',
    BT601_YUV2RGB_NV21: 24, '24': 'BT601_YUV2RGB_NV21',
    BT601_YUV2BGR_NV21: 25, '25': 'BT601_YUV2BGR_NV21',
    BT601_YUV2RGB_NV12: 26, '26': 'BT601_YUV2RGB_NV12',
    BT601_YUV2BGR_NV12: 27, '27': 'BT601_YUV2BGR_NV12',
    BT601_YUV2RGB_YV12: 28, '28': 'BT601_YUV2RGB_YV12',
    BT601_YUV2BGR_YV12: 29, '29': 'BT601_YUV2BGR_YV12',
    BT601_YUV2RGB_YU12: 30, '30': 'BT601_YUV2RGB_YU12',
    BT601_YUV2BGR_YU12: 31, '31': 'BT601_YUV2BGR_YU12'
};

mgb.serialization.fbs.param.DctChannelSelectV0FastImpl = {
    NONE: 0, '0': 'NONE',
    FIX_32_MASK: 1, '1': 'FIX_32_MASK'
};

mgb.serialization.fbs.param.ElemwiseMode = {
    RELU: 0, '0': 'RELU',
    ABS: 1, '1': 'ABS',
    ACOS: 2, '2': 'ACOS',
    ASIN: 3, '3': 'ASIN',
    CEIL: 4, '4': 'CEIL',
    COS: 5, '5': 'COS',
    EXP: 6, '6': 'EXP',
    EXPM1: 7, '7': 'EXPM1',
    FLOOR: 8, '8': 'FLOOR',
    LOG: 9, '9': 'LOG',
    LOG1P: 10, '10': 'LOG1P',
    NEGATE: 11, '11': 'NEGATE',
    SIGMOID: 12, '12': 'SIGMOID',
    SIN: 13, '13': 'SIN',
    TANH: 14, '14': 'TANH',
    ABS_GRAD: 15, '15': 'ABS_GRAD',
    ADD: 16, '16': 'ADD',
    FLOOR_DIV: 17, '17': 'FLOOR_DIV',
    MAX_: 18, '18': 'MAX_',
    MIN_: 19, '19': 'MIN_',
    MOD: 20, '20': 'MOD',
    MUL: 21, '21': 'MUL',
    POW: 22, '22': 'POW',
    SIGMOID_GRAD: 23, '23': 'SIGMOID_GRAD',
    SUB: 24, '24': 'SUB',
    SWITCH_GT0: 25, '25': 'SWITCH_GT0',
    TANH_GRAD: 26, '26': 'TANH_GRAD',
    TRUE_DIV: 27, '27': 'TRUE_DIV',
    LOG_SUM_EXP: 28, '28': 'LOG_SUM_EXP',
    LT: 29, '29': 'LT',
    LEQ: 30, '30': 'LEQ',
    EQ: 31, '31': 'EQ',
    SHL: 32, '32': 'SHL',
    SHR: 33, '33': 'SHR',
    COND_LEQ_MOV: 34, '34': 'COND_LEQ_MOV',
    FUSE_MUL_ADD3: 35, '35': 'FUSE_MUL_ADD3',
    FUSE_MUL_ADD4: 36, '36': 'FUSE_MUL_ADD4',
    FUSE_ADD_RELU: 37, '37': 'FUSE_ADD_RELU',
    FUSE_ADD_SIGMOID: 38, '38': 'FUSE_ADD_SIGMOID',
    FUSE_ADD_TANH: 39, '39': 'FUSE_ADD_TANH',
    FAST_TANH: 40, '40': 'FAST_TANH',
    FAST_TANH_GRAD: 41, '41': 'FAST_TANH_GRAD',
    ROUND: 42, '42': 'ROUND',
    RMULH: 43, '43': 'RMULH',
    ATAN2: 44, '44': 'ATAN2',
    ERF: 45, '45': 'ERF',
    ERFINV: 46, '46': 'ERFINV',
    ERFC: 47, '47': 'ERFC',
    ERFCINV: 48, '48': 'ERFCINV',
    H_SWISH: 49, '49': 'H_SWISH',
    H_SWISH_GRAD: 50, '50': 'H_SWISH_GRAD',
    FUSE_ADD_H_SWISH: 51, '51': 'FUSE_ADD_H_SWISH',
    NOT: 52, '52': 'NOT',
    AND: 53, '53': 'AND',
    OR: 54, '54': 'OR',
    XOR: 55, '55': 'XOR',
    SILU: 56, '56': 'SILU',
    SILU_GRAD: 57, '57': 'SILU_GRAD',
    GELU: 58, '58': 'GELU',
    GELU_GRAD: 59, '59': 'GELU_GRAD'
};

mgb.serialization.fbs.param.ElemwiseMultiTypeMode = {
    FUSE_MUL_ADD3_INT16x32x32x32: 0, '0': 'FUSE_MUL_ADD3_INT16x32x32x32',
    FUSE_MUL_ADD3_IXxF32xF32xI8: 1, '1': 'FUSE_MUL_ADD3_IXxF32xF32xI8',
    ROUND_SHR_SATURATE_IXxI8xI8: 2, '2': 'ROUND_SHR_SATURATE_IXxI8xI8',
    FUSE_ADD_RMULH_ROUND_SHR_SATURATE_INT16x16x16x8: 3, '3': 'FUSE_ADD_RMULH_ROUND_SHR_SATURATE_INT16x16x16x8',
    FUSE_ADD_RMULH_ROUND_SHR_SATURATE_INT32x32x32x8: 4, '4': 'FUSE_ADD_RMULH_ROUND_SHR_SATURATE_INT32x32x32x8',
    ROUND_SHR_SATURATE_IXxI8xI16: 5, '5': 'ROUND_SHR_SATURATE_IXxI8xI16',
    QADD: 6, '6': 'QADD',
    QFUSE_ADD_RELU: 7, '7': 'QFUSE_ADD_RELU',
    QMUL: 8, '8': 'QMUL',
    QMIN: 9, '9': 'QMIN',
    QMAX: 10, '10': 'QMAX',
    QSUB: 11, '11': 'QSUB',
    QTRUE_DIV: 12, '12': 'QTRUE_DIV',
    QFUSE_ADD_SIGMOID: 13, '13': 'QFUSE_ADD_SIGMOID',
    QFUSE_ADD_TANH: 14, '14': 'QFUSE_ADD_TANH',
    QRELU: 15, '15': 'QRELU',
    QABS: 16, '16': 'QABS',
    QSIGMOID: 17, '17': 'QSIGMOID',
    QEXP: 18, '18': 'QEXP',
    QTANH: 19, '19': 'QTANH',
    QFUSE_MUL_ADD3: 20, '20': 'QFUSE_MUL_ADD3',
    QFAST_TANH: 21, '21': 'QFAST_TANH',
    QNEGATE: 22, '22': 'QNEGATE',
    QACOS: 23, '23': 'QACOS',
    QASIN: 24, '24': 'QASIN',
    QCEIL: 25, '25': 'QCEIL',
    QCOS: 26, '26': 'QCOS',
    QEXPM1: 27, '27': 'QEXPM1',
    QFLOOR: 28, '28': 'QFLOOR',
    QLOG: 29, '29': 'QLOG',
    QLOG1P: 30, '30': 'QLOG1P',
    QSIN: 31, '31': 'QSIN',
    QROUND: 32, '32': 'QROUND',
    QERF: 33, '33': 'QERF',
    QERFINV: 34, '34': 'QERFINV',
    QERFC: 35, '35': 'QERFC',
    QERFCINV: 36, '36': 'QERFCINV',
    QABS_GRAD: 37, '37': 'QABS_GRAD',
    QFLOOR_DIV: 38, '38': 'QFLOOR_DIV',
    QMOD: 39, '39': 'QMOD',
    QSIGMOID_GRAD: 40, '40': 'QSIGMOID_GRAD',
    QSWITCH_GT0: 41, '41': 'QSWITCH_GT0',
    QTANH_GRAD: 42, '42': 'QTANH_GRAD',
    QLT: 43, '43': 'QLT',
    QLEQ: 44, '44': 'QLEQ',
    QEQ: 45, '45': 'QEQ',
    QPOW: 46, '46': 'QPOW',
    QLOG_SUM_EXP: 47, '47': 'QLOG_SUM_EXP',
    QFAST_TANH_GRAD: 48, '48': 'QFAST_TANH_GRAD',
    QATAN2: 49, '49': 'QATAN2',
    QCOND_LEQ_MOV: 50, '50': 'QCOND_LEQ_MOV',
    QH_SWISH: 51, '51': 'QH_SWISH',
    QFUSE_ADD_H_SWISH: 52, '52': 'QFUSE_ADD_H_SWISH',
    QH_SWISH_GRAD: 53, '53': 'QH_SWISH_GRAD',
    FUSE_MUL_ADD3_INT16xF32xF32xF32: 54, '54': 'FUSE_MUL_ADD3_INT16xF32xF32xF32',
    MUL_INT16xF32xF32: 55, '55': 'MUL_INT16xF32xF32',
    FUSE_MUL_ADD3_UINT8xF32xF32xF32: 56, '56': 'FUSE_MUL_ADD3_UINT8xF32xF32xF32'
};

mgb.serialization.fbs.param.MatrixMulFormat = {
    DEFAULT: 0, '0': 'DEFAULT',
    MK4: 1, '1': 'MK4',
    MK8: 2, '2': 'MK8',
    MK4_DOT: 3, '3': 'MK4_DOT'
};

mgb.serialization.fbs.param.MatrixMulV0DataType = {
    FLOAT: 0, '0': 'FLOAT',
    INT8x8x16: 1, '1': 'INT8x8x16',
    INT8x8x32: 2, '2': 'INT8x8x32',
    FLOAT_IO16xC32: 3, '3': 'FLOAT_IO16xC32',
    QUINT8x8x32: 4, '4': 'QUINT8x8x32',
    QUINT4x4x32: 5, '5': 'QUINT4x4x32'
};

mgb.serialization.fbs.param.MatrixMulV1ComputeMode = {
    DEFAULT: 0, '0': 'DEFAULT',
    FLOAT32: 1, '1': 'FLOAT32'
};

mgb.serialization.fbs.param.PaddingPaddingMode = {
    REPLICATE: 0, '0': 'REPLICATE',
    REFLECT: 1, '1': 'REFLECT',
    CONSTANT: 2, '2': 'CONSTANT'
};

mgb.serialization.fbs.param.PoolingV0Mode = {
    MAX_: 0, '0': 'MAX_',
    AVERAGE: 1, '1': 'AVERAGE',
    AVERAGE_COUNT_EXCLUDE_PADDING: 2, '2': 'AVERAGE_COUNT_EXCLUDE_PADDING'
};

mgb.serialization.fbs.param.RNNCellNonlineMode = {
    IDENTITY: 0, '0': 'IDENTITY',
    RELU: 1, '1': 'RELU',
    TANH: 2, '2': 'TANH'
};

mgb.serialization.fbs.param.ROIAlignV0Mode = {
    MAX_: 0, '0': 'MAX_',
    AVERAGE: 1, '1': 'AVERAGE'
};

mgb.serialization.fbs.param.ROIPoolingMode = {
    MAX_: 0, '0': 'MAX_',
    AVERAGE: 1, '1': 'AVERAGE'
};

mgb.serialization.fbs.param.ReduceDataType = {
    DEFAULT: 0, '0': 'DEFAULT',
    FLOAT_IO16xC32: 1, '1': 'FLOAT_IO16xC32',
    FLOAT_O32xC32: 2, '2': 'FLOAT_O32xC32',
    FLOAT_O16xC32: 3, '3': 'FLOAT_O16xC32',
    QUINT_I8xO32: 4, '4': 'QUINT_I8xO32',
    QINT_I8xO32: 5, '5': 'QINT_I8xO32'
};

mgb.serialization.fbs.param.ReduceMode = {
    SUM: 0, '0': 'SUM',
    SUM_SQR: 1, '1': 'SUM_SQR',
    PRODUCT: 2, '2': 'PRODUCT',
    MIN_: 3, '3': 'MIN_',
    MAX_: 4, '4': 'MAX_',
    MEAN: 5, '5': 'MEAN'
};

mgb.serialization.fbs.param.ReduceV0Mode = {
    SUM: 0, '0': 'SUM',
    SUM_SQR: 1, '1': 'SUM_SQR',
    PRODUCT: 2, '2': 'PRODUCT',
    MIN_: 3, '3': 'MIN_',
    MAX_: 4, '4': 'MAX_'
};

mgb.serialization.fbs.param.ReduceV1DataType = {
    DEFAULT: 0, '0': 'DEFAULT',
    FLOAT_IO16xC32: 1, '1': 'FLOAT_IO16xC32',
    FLOAT_O32xC32: 2, '2': 'FLOAT_O32xC32',
    FLOAT_O16xC32: 3, '3': 'FLOAT_O16xC32',
    QUINT_I8xO32: 4, '4': 'QUINT_I8xO32',
    QINT_I8xO32: 5, '5': 'QINT_I8xO32'
};

mgb.serialization.fbs.param.ReduceV1Mode = {
    SUM: 0, '0': 'SUM',
    SUM_SQR: 1, '1': 'SUM_SQR',
    PRODUCT: 2, '2': 'PRODUCT',
    MIN_: 3, '3': 'MIN_',
    MAX_: 4, '4': 'MAX_',
    MEAN: 5, '5': 'MEAN'
};

mgb.serialization.fbs.param.RelayoutFormatV0Mode = {
    NHWC_NHWCD4: 0, '0': 'NHWC_NHWCD4',
    NHWCD4_NHWC: 1, '1': 'NHWCD4_NHWC',
    NHWC_NHWCD4I: 2, '2': 'NHWC_NHWCD4I',
    NCHW_NHWCD4: 3, '3': 'NCHW_NHWCD4',
    NCHW_NHWCD4I: 4, '4': 'NCHW_NHWCD4I',
    NHWCD4I_NCHW: 5, '5': 'NHWCD4I_NCHW',
    NHWCD4_NCHW: 6, '6': 'NHWCD4_NCHW',
    INTER_WEIGHT_DENSE: 7, '7': 'INTER_WEIGHT_DENSE',
    INTER_WEIGHT_DENSEI: 8, '8': 'INTER_WEIGHT_DENSEI',
    INTER_WEIGHT_GROUP: 9, '9': 'INTER_WEIGHT_GROUP',
    INTER_WEIGHT_GROUPI: 10, '10': 'INTER_WEIGHT_GROUPI',
    INTER_WEIGHT_CHAN: 11, '11': 'INTER_WEIGHT_CHAN',
    INTER_WEIGHT_CHANI: 12, '12': 'INTER_WEIGHT_CHANI',
    INTER_WEIGHT_DENSEI_DOT: 13, '13': 'INTER_WEIGHT_DENSEI_DOT',
    INTER_WEIGHT_GROUPI_DOT: 14, '14': 'INTER_WEIGHT_GROUPI_DOT',
    NCHW4_CHWN4: 15, '15': 'NCHW4_CHWN4',
    CHWN4_NCHW4: 16, '16': 'CHWN4_NCHW4',
    NCHW_NCHW88_CONV_DENSE_WEIGHT: 17, '17': 'NCHW_NCHW88_CONV_DENSE_WEIGHT',
    NCHW_NCHW88_CONV_CHAN_WEIGHT: 18, '18': 'NCHW_NCHW88_CONV_CHAN_WEIGHT',
    NCHW_NCHW88_CONV_GROUP_WEIGHT: 19, '19': 'NCHW_NCHW88_CONV_GROUP_WEIGHT',
    NCHW_NCHW88: 20, '20': 'NCHW_NCHW88',
    NCHW88_NCHW: 21, '21': 'NCHW88_NCHW',
    NCHW_NCHW4_IC_SMALL: 22, '22': 'NCHW_NCHW4_IC_SMALL',
    NCHW_NCHW4_IC_SMALL_CONV_DENSE_WEIGHT: 23, '23': 'NCHW_NCHW4_IC_SMALL_CONV_DENSE_WEIGHT',
    NCHW_NCHW4: 24, '24': 'NCHW_NCHW4',
    NCHW4_NCHW: 25, '25': 'NCHW4_NCHW',
    NCHW_NCHW4_WEIGHT: 26, '26': 'NCHW_NCHW4_WEIGHT',
    NCHW_NCHW64: 27, '27': 'NCHW_NCHW64',
    NCHW64_NCHW: 28, '28': 'NCHW64_NCHW',
    NCHW_NHWC: 29, '29': 'NCHW_NHWC',
    NHWC_NCHW: 30, '30': 'NHWC_NCHW',
    NHWCD4I_NHWC: 31, '31': 'NHWCD4I_NHWC'
};

mgb.serialization.fbs.param.SeparableConvBorderMode = {
    BORDER_REPLICATE: 0, '0': 'BORDER_REPLICATE',
    BORDER_REFLECT: 1, '1': 'BORDER_REFLECT',
    BORDER_REFLECT_101: 2, '2': 'BORDER_REFLECT_101',
    BORDER_WRAP: 3, '3': 'BORDER_WRAP',
    BORDER_CONSTANT: 4, '4': 'BORDER_CONSTANT',
    BORDER_TRANSPARENT: 5, '5': 'BORDER_TRANSPARENT',
    BORDER_ISOLATED: 6, '6': 'BORDER_ISOLATED'
};

mgb.serialization.fbs.param.SeparableConv3DBorderMode = {
    BORDER_REPLICATE: 0, '0': 'BORDER_REPLICATE',
    BORDER_REFLECT: 1, '1': 'BORDER_REFLECT',
    BORDER_REFLECT_101: 2, '2': 'BORDER_REFLECT_101',
    BORDER_WRAP: 3, '3': 'BORDER_WRAP',
    BORDER_CONSTANT: 4, '4': 'BORDER_CONSTANT',
    BORDER_TRANSPARENT: 5, '5': 'BORDER_TRANSPARENT',
    BORDER_ISOLATED: 6, '6': 'BORDER_ISOLATED'
};

mgb.serialization.fbs.param.SpatialTfGridGeneratorMode = {
    AFFINE: 0, '0': 'AFFINE'
};

mgb.serialization.fbs.param.SpatialTfSamplerMode = {
    BILINEAR: 0, '0': 'BILINEAR'
};

mgb.serialization.fbs.param.TopKMode = {
    KTH_ONLY: 0, '0': 'KTH_ONLY',
    VALUE_IDX_NOSORT: 1, '1': 'VALUE_IDX_NOSORT',
    VALUE_IDX_SORTED: 2, '2': 'VALUE_IDX_SORTED'
};

mgb.serialization.fbs.param.WarpPerspectiveV1BorderMode = {
    REPLICATE: 0, '0': 'REPLICATE',
    REFLECT: 1, '1': 'REFLECT',
    REFLECT_101: 2, '2': 'REFLECT_101',
    WRAP: 3, '3': 'WRAP',
    CONSTANT: 4, '4': 'CONSTANT',
    TRANSPARENT: 5, '5': 'TRANSPARENT',
    ISOLATED: 6, '6': 'ISOLATED'
};

mgb.serialization.fbs.param.WarpPerspectiveV1InterpolationMode = {
    NEAREST: 0, '0': 'NEAREST',
    LINEAR: 1, '1': 'LINEAR',
    AREA: 2, '2': 'AREA',
    CUBIC: 3, '3': 'CUBIC',
    LANCZOS4: 4, '4': 'LANCZOS4'
};

mgb.serialization.fbs.param.Empty = class Empty {

    static decode(/* reader, position */) {
        const $ = new mgb.serialization.fbs.param.Empty();
        return $;
    }
};

mgb.serialization.fbs.param.Axis = class Axis {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Axis();
        $.axis = reader.int32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ConvolutionV0 = class ConvolutionV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvolutionV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 1);
        $.stride_w = reader.uint32_(position, 12, 1);
        $.dilate_h = reader.uint32_(position, 14, 1);
        $.dilate_w = reader.uint32_(position, 16, 1);
        $.data_type = reader.uint32_(position, 18, 0);
        $.sparse = reader.uint32_(position, 20, 0);
        $.format = reader.uint32_(position, 22, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ConvolutionV1 = class ConvolutionV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvolutionV1();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 1);
        $.stride_w = reader.uint32_(position, 12, 1);
        $.dilate_h = reader.uint32_(position, 14, 1);
        $.dilate_w = reader.uint32_(position, 16, 1);
        $.sparse = reader.uint32_(position, 18, 0);
        $.format = reader.uint32_(position, 20, 0);
        $.compute_mode = reader.uint32_(position, 22, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Convolution = class Convolution {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Convolution();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 1);
        $.stride_w = reader.uint32_(position, 12, 1);
        $.dilate_h = reader.uint32_(position, 14, 1);
        $.dilate_w = reader.uint32_(position, 16, 1);
        $.sparse = reader.uint32_(position, 18, 0);
        $.format = reader.uint32_(position, 20, 0);
        $.compute_mode = reader.uint32_(position, 22, 0);
        return $;
    }
};

mgb.serialization.fbs.param.MaskPropagate = class MaskPropagate {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MaskPropagate();
        $.pad_h = reader.uint32_(position, 4, 0);
        $.pad_w = reader.uint32_(position, 6, 0);
        $.stride_h = reader.uint32_(position, 8, 1);
        $.stride_w = reader.uint32_(position, 10, 1);
        $.kernel_h = reader.uint32_(position, 12, 1);
        $.kernel_w = reader.uint32_(position, 14, 1);
        $.dilate_h = reader.uint32_(position, 16, 1);
        $.dilate_w = reader.uint32_(position, 18, 1);
        return $;
    }
};

mgb.serialization.fbs.param.ConvPooling = class ConvPooling {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvPooling();
        $.method = reader.uint32_(position, 4, 0);
        $.convMode = reader.uint32_(position, 6, 0);
        $.poolMode = reader.uint32_(position, 8, 0);
        $.nonlineMode = reader.uint32_(position, 10, 0);
        $.pool_shape_h = reader.uint32_(position, 12, 1);
        $.pool_shape_w = reader.uint32_(position, 14, 1);
        $.pool_stride_h = reader.uint32_(position, 16, 1);
        $.pool_stride_w = reader.uint32_(position, 18, 1);
        $.pool_pad_h = reader.uint32_(position, 20, 0);
        $.pool_pad_w = reader.uint32_(position, 22, 0);
        $.conv_stride_h = reader.uint32_(position, 24, 1);
        $.conv_stride_w = reader.uint32_(position, 26, 1);
        $.conv_pad_h = reader.uint32_(position, 28, 0);
        $.conv_pad_w = reader.uint32_(position, 30, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ConvBiasV0 = class ConvBiasV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvBiasV0();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.pad_h = reader.uint32_(position, 8, 0);
        $.pad_w = reader.uint32_(position, 10, 0);
        $.stride_h = reader.uint32_(position, 12, 1);
        $.stride_w = reader.uint32_(position, 14, 1);
        return $;
    }
};

mgb.serialization.fbs.param.ConvBiasV1 = class ConvBiasV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvBiasV1();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.data_type = reader.uint32_(position, 8, 0);
        $.sparse = reader.uint32_(position, 10, 0);
        $.format = reader.uint32_(position, 12, 0);
        $.pad_h = reader.uint32_(position, 14, 0);
        $.pad_w = reader.uint32_(position, 16, 0);
        $.stride_h = reader.uint32_(position, 18, 1);
        $.stride_w = reader.uint32_(position, 20, 1);
        $.dilate_h = reader.uint32_(position, 22, 1);
        $.dilate_w = reader.uint32_(position, 24, 1);
        return $;
    }
};

mgb.serialization.fbs.param.ConvBiasV2 = class ConvBiasV2 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvBiasV2();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.sparse = reader.uint32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 0);
        $.pad_h = reader.uint32_(position, 12, 0);
        $.pad_w = reader.uint32_(position, 14, 0);
        $.stride_h = reader.uint32_(position, 16, 1);
        $.stride_w = reader.uint32_(position, 18, 1);
        $.dilate_h = reader.uint32_(position, 20, 1);
        $.dilate_w = reader.uint32_(position, 22, 1);
        $.compute_mode = reader.uint32_(position, 24, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ConvBiasV3 = class ConvBiasV3 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvBiasV3();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.sparse = reader.uint32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 0);
        $.pad_h = reader.uint32_(position, 12, 0);
        $.pad_w = reader.uint32_(position, 14, 0);
        $.stride_h = reader.uint32_(position, 16, 1);
        $.stride_w = reader.uint32_(position, 18, 1);
        $.dilate_h = reader.uint32_(position, 20, 1);
        $.dilate_w = reader.uint32_(position, 22, 1);
        $.output_block_size = reader.uint32_(position, 24, 0);
        $.compute_mode = reader.uint32_(position, 26, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ConvBias = class ConvBias {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ConvBias();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.sparse = reader.uint32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 0);
        $.pad_h = reader.uint32_(position, 12, 0);
        $.pad_w = reader.uint32_(position, 14, 0);
        $.stride_h = reader.uint32_(position, 16, 1);
        $.stride_w = reader.uint32_(position, 18, 1);
        $.dilate_h = reader.uint32_(position, 20, 1);
        $.dilate_w = reader.uint32_(position, 22, 1);
        $.compute_mode = reader.uint32_(position, 24, 0);
        return $;
    }
};

mgb.serialization.fbs.param.SeparableConv = class SeparableConv {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SeparableConv();
        $.mode = reader.uint32_(position, 4, 0);
        $.borderMode = reader.uint32_(position, 6, 0);
        $.is_symm_kernel = reader.bool_(position, 8, true);
        $.pad_h = reader.uint32_(position, 10, 0);
        $.pad_w = reader.uint32_(position, 12, 0);
        $.stride_h = reader.uint32_(position, 14, 1);
        $.stride_w = reader.uint32_(position, 16, 1);
        $.ksize_h = reader.uint32_(position, 18, 3);
        $.ksize_w = reader.uint32_(position, 20, 3);
        $.anchor_h = reader.uint32_(position, 22, 1);
        $.anchor_w = reader.uint32_(position, 24, 1);
        return $;
    }
};

mgb.serialization.fbs.param.Images2Neibs = class Images2Neibs {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Images2Neibs();
        $.pad_h = reader.uint32_(position, 4, 0);
        $.pad_w = reader.uint32_(position, 6, 0);
        $.stride_h = reader.uint32_(position, 8, 1);
        $.stride_w = reader.uint32_(position, 10, 1);
        $.dilate_h = reader.uint32_(position, 12, 1);
        $.dilate_w = reader.uint32_(position, 14, 1);
        $.window_h = reader.uint32_(position, 16, 3);
        $.window_w = reader.uint32_(position, 18, 3);
        return $;
    }
};

mgb.serialization.fbs.param.SlidingWindowTranspose = class SlidingWindowTranspose {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SlidingWindowTranspose();
        $.out_h = reader.uint32_(position, 4, 0);
        $.out_w = reader.uint32_(position, 6, 0);
        $.pad_h = reader.uint32_(position, 8, 0);
        $.pad_w = reader.uint32_(position, 10, 0);
        $.stride_h = reader.uint32_(position, 12, 1);
        $.stride_w = reader.uint32_(position, 14, 1);
        $.dilate_h = reader.uint32_(position, 16, 1);
        $.dilate_w = reader.uint32_(position, 18, 1);
        $.window_h = reader.uint32_(position, 20, 3);
        $.window_w = reader.uint32_(position, 22, 3);
        return $;
    }
};

mgb.serialization.fbs.param.PoolingV0 = class PoolingV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PoolingV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 2);
        $.stride_w = reader.uint32_(position, 12, 2);
        $.window_h = reader.uint32_(position, 14, 2);
        $.window_w = reader.uint32_(position, 16, 2);
        $.format = reader.uint32_(position, 18, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Pooling = class Pooling {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Pooling();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 2);
        $.stride_w = reader.uint32_(position, 12, 2);
        $.window_h = reader.uint32_(position, 14, 2);
        $.window_w = reader.uint32_(position, 16, 2);
        $.format = reader.uint32_(position, 18, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Softmax = class Softmax {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Softmax();
        $.axis = reader.int32_(position, 4, -1);
        return $;
    }
};

mgb.serialization.fbs.param.AdaptivePoolingV0 = class AdaptivePoolingV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AdaptivePoolingV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.format = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.AdaptivePooling = class AdaptivePooling {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AdaptivePooling();
        $.mode = reader.uint32_(position, 4, 0);
        $.format = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.LRN = class LRN {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LRN();
        $.n = reader.uint32_(position, 4, 5);
        $.k = reader.float32_(position, 6, 2);
        $.alpha = reader.float32_(position, 8, 0.0001);
        $.beta = reader.float32_(position, 10, 0.75);
        return $;
    }
};

mgb.serialization.fbs.param.BN = class BN {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.BN();
        $.param_dim = reader.uint32_(position, 4, 0);
        $.fwd_mode = reader.uint32_(position, 6, 0);
        $.epsilon = reader.float64_(position, 8, 0.0001);
        $.avg_factor = reader.float64_(position, 10, 1);
        $.scale = reader.float32_(position, 12, 1);
        $.bias = reader.float32_(position, 14, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ROIPooling = class ROIPooling {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ROIPooling();
        $.mode = reader.uint32_(position, 4, 0);
        $.scale = reader.float32_(position, 6, 1);
        return $;
    }
};

mgb.serialization.fbs.param.WarpPerspectiveV1 = class WarpPerspectiveV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.WarpPerspectiveV1();
        $.imode = reader.uint32_(position, 4, 1);
        $.bmode = reader.uint32_(position, 6, 0);
        $.format = reader.uint32_(position, 8, 0);
        $.border_val = reader.float32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.WarpPerspective = class WarpPerspective {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.WarpPerspective();
        $.imode = reader.uint32_(position, 4, 1);
        $.bmode = reader.uint32_(position, 6, 0);
        $.format = reader.uint32_(position, 8, 0);
        $.border_val = reader.float32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.SpatialTfGridGenerator = class SpatialTfGridGenerator {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SpatialTfGridGenerator();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.SpatialTfSampler = class SpatialTfSampler {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SpatialTfSampler();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.AddUpdate = class AddUpdate {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AddUpdate();
        $.alpha = reader.float32_(position, 4, 1);
        $.beta = reader.float32_(position, 6, 1);
        $.bias = reader.float32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Elemwise = class Elemwise {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Elemwise();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ElemwiseMultiType = class ElemwiseMultiType {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ElemwiseMultiType();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.PowC = class PowC {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PowC();
        $.exp = reader.float32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.DctChannelSelectV0 = class DctChannelSelectV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.DctChannelSelectV0();
        $.format = reader.uint32_(position, 4, 0);
        $.fastImpl = reader.uint32_(position, 6, 0);
        $.dct_block_size = reader.int32_(position, 8, 8);
        return $;
    }
};

mgb.serialization.fbs.param.DctChannelSelect = class DctChannelSelect {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.DctChannelSelect();
        $.format = reader.uint32_(position, 4, 0);
        $.fastImpl = reader.uint32_(position, 6, 0);
        $.dct_block_size = reader.int32_(position, 8, 8);
        return $;
    }
};

mgb.serialization.fbs.param.MatrixMulV0 = class MatrixMulV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MatrixMulV0();
        $.transposeA = reader.bool_(position, 4, false);
        $.transposeB = reader.bool_(position, 6, false);
        $.data_type = reader.uint32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.MatrixMulV1 = class MatrixMulV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MatrixMulV1();
        $.transposeA = reader.bool_(position, 4, false);
        $.transposeB = reader.bool_(position, 6, false);
        $.compute_mode = reader.uint32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.MatrixMul = class MatrixMul {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MatrixMul();
        $.transposeA = reader.bool_(position, 4, false);
        $.transposeB = reader.bool_(position, 6, false);
        $.compute_mode = reader.uint32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.SVD = class SVD {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SVD();
        $.full_matrices = reader.bool_(position, 4, false);
        $.compute_uv = reader.bool_(position, 6, true);
        return $;
    }
};

mgb.serialization.fbs.param.ReduceV0 = class ReduceV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ReduceV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.axis = reader.int32_(position, 6, -1);
        return $;
    }
};

mgb.serialization.fbs.param.ReduceV1 = class ReduceV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ReduceV1();
        $.mode = reader.uint32_(position, 4, 0);
        $.axis = reader.int32_(position, 6, -1);
        $.data_type = reader.uint32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Reduce = class Reduce {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Reduce();
        $.mode = reader.uint32_(position, 4, 0);
        $.axis = reader.int32_(position, 6, 2147483647);
        $.data_type = reader.uint32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CumsumV0 = class CumsumV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CumsumV0();
        $.axis = reader.int32_(position, 4, -1);
        $.exclusive = reader.bool_(position, 6, true);
        $.reverse = reader.bool_(position, 8, false);
        return $;
    }
};

mgb.serialization.fbs.param.Cumsum = class Cumsum {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Cumsum();
        $.axis = reader.int32_(position, 4, 2147483647);
        $.exclusive = reader.bool_(position, 6, true);
        $.reverse = reader.bool_(position, 8, false);
        return $;
    }
};

mgb.serialization.fbs.param.CondTake = class CondTake {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CondTake();
        $.mode = reader.uint32_(position, 4, 0);
        $.val = reader.float32_(position, 6, 0);
        $.eps = reader.float32_(position, 8, 0.000001);
        return $;
    }
};

mgb.serialization.fbs.param.Argsort = class Argsort {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Argsort();
        $.order = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.IndexingRemap = class IndexingRemap {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.IndexingRemap();
        $.is_non_overlapping = reader.bool_(position, 4, false);
        return $;
    }
};

mgb.serialization.fbs.param.Sleep = class Sleep {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Sleep();
        $.time = reader.float32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Linspace = class Linspace {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Linspace();
        $.endpoint = reader.bool_(position, 4, true);
        return $;
    }
};

mgb.serialization.fbs.param.LinspaceFull = class LinspaceFull {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LinspaceFull();
        $.start = reader.float64_(position, 4, 0);
        $.stop = reader.float64_(position, 6, 1);
        $.endpoint = reader.bool_(position, 8, true);
        return $;
    }
};

mgb.serialization.fbs.param.Eye = class Eye {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Eye();
        $.k = reader.int32_(position, 4, 0);
        $.dtype = reader.int8_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Diag = class Diag {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Diag();
        $.k = reader.int32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.UniformRNGV0 = class UniformRNGV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.UniformRNGV0();
        $.seed = reader.uint64_(position, 4, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.UniformRNG = class UniformRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.UniformRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        $.dtype = reader.int8_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.GaussianRNGV0 = class GaussianRNGV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.GaussianRNGV0();
        $.seed = reader.uint64_(position, 4, 0n);
        $.mean = reader.float32_(position, 6, 0);
        $.std = reader.float32_(position, 8, 1);
        return $;
    }
};

mgb.serialization.fbs.param.GaussianRNG = class GaussianRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.GaussianRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        $.mean = reader.float32_(position, 6, 0);
        $.std = reader.float32_(position, 8, 1);
        $.dtype = reader.int8_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.GammaRNG = class GammaRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.GammaRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.BetaRNG = class BetaRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.BetaRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.PoissonRNG = class PoissonRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PoissonRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.MultinomialRNG = class MultinomialRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MultinomialRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        $.num_samples = reader.uint64_(position, 6, 1n);
        $.replacement = reader.bool_(position, 8, false);
        return $;
    }
};

mgb.serialization.fbs.param.PermutationRNG = class PermutationRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PermutationRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        $.dtype = reader.int8_(position, 6, 4);
        return $;
    }
};

mgb.serialization.fbs.param.ShuffleRNG = class ShuffleRNG {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ShuffleRNG();
        $.seed = reader.uint64_(position, 4, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.Flip = class Flip {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Flip();
        $.vertical = reader.bool_(position, 4, false);
        $.horizontal = reader.bool_(position, 6, false);
        return $;
    }
};

mgb.serialization.fbs.param.Rotate = class Rotate {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Rotate();
        $.clockwise = reader.bool_(position, 4, true);
        return $;
    }
};

mgb.serialization.fbs.param.ROICopy = class ROICopy {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ROICopy();
        $.row_from = reader.uint32_(position, 4, 0);
        $.row_to = reader.uint32_(position, 6, 0);
        $.col_from = reader.uint32_(position, 8, 0);
        $.col_to = reader.uint32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CvtColor = class CvtColor {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CvtColor();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.WarpAffineV0 = class WarpAffineV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.WarpAffineV0();
        $.imode = reader.uint32_(position, 4, 1);
        $.border_mode = reader.uint32_(position, 6, 0);
        $.border_val = reader.float32_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.WarpAffineV1 = class WarpAffineV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.WarpAffineV1();
        $.imode = reader.uint32_(position, 4, 1);
        $.border_mode = reader.uint32_(position, 6, 0);
        $.border_val = reader.float32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 1);
        return $;
    }
};

mgb.serialization.fbs.param.WarpAffine = class WarpAffine {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.WarpAffine();
        $.imode = reader.uint32_(position, 4, 1);
        $.border_mode = reader.uint32_(position, 6, 0);
        $.border_val = reader.float32_(position, 8, 0);
        $.format = reader.uint32_(position, 10, 1);
        return $;
    }
};

mgb.serialization.fbs.param.GaussianBlur = class GaussianBlur {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.GaussianBlur();
        $.border_mode = reader.uint32_(position, 4, 0);
        $.kernel_height = reader.uint32_(position, 6, 0);
        $.kernel_width = reader.uint32_(position, 8, 0);
        $.sigma_x = reader.float32_(position, 10, 0);
        $.sigma_y = reader.float32_(position, 12, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ResizeV0 = class ResizeV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ResizeV0();
        $.imode = reader.uint32_(position, 4, 1);
        return $;
    }
};

mgb.serialization.fbs.param.ResizeV1 = class ResizeV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ResizeV1();
        $.imode = reader.uint32_(position, 4, 1);
        $.format = reader.uint32_(position, 6, 1);
        return $;
    }
};

mgb.serialization.fbs.param.Resize = class Resize {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Resize();
        $.imode = reader.uint32_(position, 4, 1);
        $.format = reader.uint32_(position, 6, 1);
        return $;
    }
};

mgb.serialization.fbs.param.RemapV0 = class RemapV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.RemapV0();
        $.imode = reader.uint32_(position, 4, 1);
        $.border_type = reader.uint32_(position, 6, 0);
        $.format = reader.uint32_(position, 8, 1);
        $.scalar = reader.float32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Remap = class Remap {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Remap();
        $.imode = reader.uint32_(position, 4, 1);
        $.border_type = reader.uint32_(position, 6, 0);
        $.format = reader.uint32_(position, 8, 1);
        $.scalar = reader.float32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Convolution3D = class Convolution3D {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Convolution3D();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_d = reader.uint32_(position, 6, 0);
        $.pad_h = reader.uint32_(position, 8, 0);
        $.pad_w = reader.uint32_(position, 10, 0);
        $.stride_d = reader.uint32_(position, 12, 1);
        $.stride_h = reader.uint32_(position, 14, 1);
        $.stride_w = reader.uint32_(position, 16, 1);
        $.dilate_d = reader.uint32_(position, 18, 1);
        $.dilate_h = reader.uint32_(position, 20, 1);
        $.dilate_w = reader.uint32_(position, 22, 1);
        $.sparse = reader.uint32_(position, 24, 0);
        $.data_type = reader.uint32_(position, 26, 0);
        $.format = reader.uint32_(position, 28, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Conv3DBias = class Conv3DBias {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Conv3DBias();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.pad_d = reader.uint32_(position, 8, 0);
        $.pad_h = reader.uint32_(position, 10, 0);
        $.pad_w = reader.uint32_(position, 12, 0);
        $.stride_d = reader.uint32_(position, 14, 1);
        $.stride_h = reader.uint32_(position, 16, 1);
        $.stride_w = reader.uint32_(position, 18, 0);
        return $;
    }
};

mgb.serialization.fbs.param.SeparableConv3D = class SeparableConv3D {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SeparableConv3D();
        $.mode = reader.uint32_(position, 4, 0);
        $.borderMode = reader.uint32_(position, 6, 0);
        $.is_symm_kernel = reader.bool_(position, 8, true);
        $.pad_d = reader.uint32_(position, 10, 0);
        $.pad_h = reader.uint32_(position, 12, 0);
        $.pad_w = reader.uint32_(position, 14, 0);
        $.stride_d = reader.uint32_(position, 16, 0);
        $.stride_h = reader.uint32_(position, 18, 1);
        $.stride_w = reader.uint32_(position, 20, 1);
        $.ksize_d = reader.uint32_(position, 22, 0);
        $.ksize_h = reader.uint32_(position, 24, 3);
        $.ksize_w = reader.uint32_(position, 26, 3);
        $.anchor_d = reader.uint32_(position, 28, 0);
        $.anchor_h = reader.uint32_(position, 30, 1);
        $.anchor_w = reader.uint32_(position, 32, 1);
        return $;
    }
};

mgb.serialization.fbs.param.TopK = class TopK {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.TopK();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.RelayoutFormatV0 = class RelayoutFormatV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.RelayoutFormatV0();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.RelayoutFormat = class RelayoutFormat {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.RelayoutFormat();
        $.mode = reader.uint32_(position, 4, 0);
        $.oc = reader.uint32_(position, 6, 0);
        $.group = reader.uint32_(position, 8, 1);
        return $;
    }
};

mgb.serialization.fbs.param.SeparableFilterV0 = class SeparableFilterV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SeparableFilterV0();
        $.format = reader.uint32_(position, 4, 0);
        $.borderMode = reader.uint32_(position, 6, 0);
        $.is_symm_kernel = reader.bool_(position, 8, true);
        $.ksize_h = reader.uint32_(position, 10, 3);
        $.ksize_w = reader.uint32_(position, 12, 3);
        $.anchor_h = reader.uint32_(position, 14, 1);
        $.anchor_w = reader.uint32_(position, 16, 1);
        return $;
    }
};

mgb.serialization.fbs.param.SeparableFilter = class SeparableFilter {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.SeparableFilter();
        $.format = reader.uint32_(position, 4, 0);
        $.borderMode = reader.uint32_(position, 6, 0);
        $.is_symm_kernel = reader.bool_(position, 8, true);
        $.ksize_h = reader.uint32_(position, 10, 3);
        $.ksize_w = reader.uint32_(position, 12, 3);
        $.anchor_h = reader.uint32_(position, 14, 1);
        $.anchor_w = reader.uint32_(position, 16, 1);
        return $;
    }
};

mgb.serialization.fbs.param.LocalShareV0 = class LocalShareV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LocalShareV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 1);
        $.stride_w = reader.uint32_(position, 12, 1);
        $.dilate_h = reader.uint32_(position, 14, 1);
        $.dilate_w = reader.uint32_(position, 16, 1);
        $.spatial_groups_h = reader.uint32_(position, 18, 1);
        $.spatial_groups_w = reader.uint32_(position, 20, 1);
        $.sparse = reader.uint32_(position, 22, 0);
        $.format = reader.uint32_(position, 24, 0);
        $.computeMode = reader.uint32_(position, 26, 0);
        return $;
    }
};

mgb.serialization.fbs.param.LocalShare = class LocalShare {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LocalShare();
        $.mode = reader.uint32_(position, 4, 0);
        $.pad_h = reader.uint32_(position, 6, 0);
        $.pad_w = reader.uint32_(position, 8, 0);
        $.stride_h = reader.uint32_(position, 10, 1);
        $.stride_w = reader.uint32_(position, 12, 1);
        $.dilate_h = reader.uint32_(position, 14, 1);
        $.dilate_w = reader.uint32_(position, 16, 1);
        $.spatial_groups_h = reader.uint32_(position, 18, 1);
        $.spatial_groups_w = reader.uint32_(position, 20, 1);
        $.sparse = reader.uint32_(position, 22, 0);
        $.format = reader.uint32_(position, 24, 0);
        $.computeMode = reader.uint32_(position, 26, 0);
        return $;
    }
};

mgb.serialization.fbs.param.ROIAlignV0 = class ROIAlignV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ROIAlignV0();
        $.mode = reader.uint32_(position, 4, 0);
        $.format = reader.uint32_(position, 6, 0);
        $.spatial_scale = reader.float32_(position, 8, 1);
        $.offset = reader.float32_(position, 10, 0);
        $.pooled_height = reader.uint32_(position, 12, 1);
        $.pooled_width = reader.uint32_(position, 14, 1);
        $.sample_height = reader.uint32_(position, 16, 2);
        $.sample_width = reader.uint32_(position, 18, 2);
        return $;
    }
};

mgb.serialization.fbs.param.ROIAlign = class ROIAlign {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ROIAlign();
        $.mode = reader.uint32_(position, 4, 0);
        $.format = reader.uint32_(position, 6, 0);
        $.spatial_scale = reader.float32_(position, 8, 1);
        $.offset = reader.float32_(position, 10, 0);
        $.pooled_height = reader.uint32_(position, 12, 1);
        $.pooled_width = reader.uint32_(position, 14, 1);
        $.sample_height = reader.uint32_(position, 16, 2);
        $.sample_width = reader.uint32_(position, 18, 2);
        return $;
    }
};

mgb.serialization.fbs.param.Correlation = class Correlation {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Correlation();
        $.format = reader.uint32_(position, 4, 0);
        $.kernel_size = reader.uint32_(position, 6, 1);
        $.max_displacement = reader.uint32_(position, 8, 1);
        $.stride1 = reader.uint32_(position, 10, 1);
        $.stride2 = reader.uint32_(position, 12, 1);
        $.pad_size = reader.uint32_(position, 14, 0);
        $.is_multiply = reader.bool_(position, 16, true);
        return $;
    }
};

mgb.serialization.fbs.param.DeformablePSROIPooling = class DeformablePSROIPooling {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.DeformablePSROIPooling();
        $.no_trans = reader.bool_(position, 4, true);
        $.spatial_scale = reader.float32_(position, 6, 1);
        $.trans_std = reader.float32_(position, 8, 1);
        $.pooled_h = reader.uint32_(position, 10, 1);
        $.pooled_w = reader.uint32_(position, 12, 1);
        $.part_size = reader.uint32_(position, 14, 1);
        $.sample_per_part = reader.uint32_(position, 16, 1);
        return $;
    }
};

mgb.serialization.fbs.param.BatchConvBiasV0 = class BatchConvBiasV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.BatchConvBiasV0();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.pad_h = reader.uint32_(position, 8, 0);
        $.pad_w = reader.uint32_(position, 10, 0);
        $.stride_h = reader.uint32_(position, 12, 1);
        $.stride_w = reader.uint32_(position, 14, 1);
        $.dilate_h = reader.uint32_(position, 16, 1);
        $.dilate_w = reader.uint32_(position, 18, 1);
        $.sparse = reader.uint32_(position, 20, 0);
        $.format = reader.uint32_(position, 22, 0);
        $.compute_mode = reader.uint32_(position, 24, 0);
        return $;
    }
};

mgb.serialization.fbs.param.BatchConvBias = class BatchConvBias {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.BatchConvBias();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        $.mode = reader.uint32_(position, 6, 0);
        $.pad_h = reader.uint32_(position, 8, 0);
        $.pad_w = reader.uint32_(position, 10, 0);
        $.stride_h = reader.uint32_(position, 12, 1);
        $.stride_w = reader.uint32_(position, 14, 1);
        $.dilate_h = reader.uint32_(position, 16, 1);
        $.dilate_w = reader.uint32_(position, 18, 1);
        $.sparse = reader.uint32_(position, 20, 0);
        $.format = reader.uint32_(position, 22, 0);
        $.compute_mode = reader.uint32_(position, 24, 0);
        return $;
    }
};

mgb.serialization.fbs.param.FakeQuant = class FakeQuant {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.FakeQuant();
        $.qmin = reader.int32_(position, 4, -2147483648);
        $.qmax = reader.int32_(position, 6, 2147483647);
        return $;
    }
};

mgb.serialization.fbs.param.TQT = class TQT {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.TQT();
        $.qmin = reader.int32_(position, 4, -2147483648);
        $.qmax = reader.int32_(position, 6, 2147483647);
        return $;
    }
};

mgb.serialization.fbs.param.LSQ = class LSQ {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LSQ();
        $.qmin = reader.int32_(position, 4, -2147483648);
        $.qmax = reader.int32_(position, 6, 2147483647);
        return $;
    }
};

mgb.serialization.fbs.param.Fill = class Fill {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Fill();
        $.value = reader.float32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CheckNonFinite = class CheckNonFinite {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CheckNonFinite();
        $.scale = reader.float32_(position, 4, 1);
        return $;
    }
};

mgb.serialization.fbs.param.Padding = class Padding {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Padding();
        $.front_offset_dim0 = reader.uint32_(position, 4, 0);
        $.front_offset_dim1 = reader.uint32_(position, 6, 0);
        $.front_offset_dim2 = reader.uint32_(position, 8, 0);
        $.front_offset_dim3 = reader.uint32_(position, 10, 0);
        $.front_offset_dim4 = reader.uint32_(position, 12, 0);
        $.front_offset_dim5 = reader.uint32_(position, 14, 0);
        $.front_offset_dim6 = reader.uint32_(position, 16, 0);
        $.back_offset_dim0 = reader.uint32_(position, 18, 0);
        $.back_offset_dim1 = reader.uint32_(position, 20, 0);
        $.back_offset_dim2 = reader.uint32_(position, 22, 0);
        $.back_offset_dim3 = reader.uint32_(position, 24, 0);
        $.back_offset_dim4 = reader.uint32_(position, 26, 0);
        $.back_offset_dim5 = reader.uint32_(position, 28, 0);
        $.back_offset_dim6 = reader.uint32_(position, 30, 0);
        $.padding_val = reader.float32_(position, 32, 0);
        $.padding_mode = reader.uint32_(position, 34, 2);
        return $;
    }
};

mgb.serialization.fbs.param.LayerNorm = class LayerNorm {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LayerNorm();
        $.affine = reader.bool_(position, 4, true);
        $.eps = reader.float32_(position, 6, 0.00001);
        $.normalized_dim = reader.uint64_(position, 8, 1n);
        $.normalized_size = reader.uint64_(position, 10, 1n);
        return $;
    }
};

mgb.serialization.fbs.param.GroupNorm = class GroupNorm {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.GroupNorm();
        $.affine = reader.bool_(position, 4, true);
        $.eps = reader.float32_(position, 6, 0.00001);
        $.group = reader.uint32_(position, 8, 1);
        $.format = reader.uint32_(position, 10, 0);
        return $;
    }
};

mgb.serialization.fbs.param.Dropout = class Dropout {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Dropout();
        $.drop_prob = reader.float32_(position, 4, 0);
        $.seed = reader.uint64_(position, 6, 0n);
        return $;
    }
};

mgb.serialization.fbs.param.RNNCell = class RNNCell {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.RNNCell();
        $.nonlineMode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.RNN = class RNN {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.RNN();
        $.num_layers = reader.uint32_(position, 4, 1);
        $.bidirectional = reader.bool_(position, 6, false);
        $.bias = reader.bool_(position, 8, true);
        $.hidden_size = reader.uint32_(position, 10, 128);
        $.dropout = reader.float32_(position, 12, 0);
        $.nonlineMode = reader.uint32_(position, 14, 0);
        $.fwd_mode = reader.uint32_(position, 16, 0);
        return $;
    }
};

mgb.serialization.fbs.param.LSTM = class LSTM {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.LSTM();
        $.num_layers = reader.uint32_(position, 4, 1);
        $.bidirectional = reader.bool_(position, 6, false);
        $.bias = reader.bool_(position, 8, true);
        $.hidden_size = reader.uint32_(position, 10, 128);
        $.proj_size = reader.uint32_(position, 12, 0);
        $.dropout = reader.float32_(position, 14, 0);
        $.fwd_mode = reader.uint32_(position, 16, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CollectiveCommMode = {
    REDUCE_SUM: 0, '0': 'REDUCE_SUM',
    BROADCAST: 1, '1': 'BROADCAST',
    ALL_GATHER: 2, '2': 'ALL_GATHER',
    REDUCE_SCATTER_SUM: 3, '3': 'REDUCE_SCATTER_SUM',
    ALL_REDUCE_SUM: 4, '4': 'ALL_REDUCE_SUM',
    ALL_REDUCE_MAX: 5, '5': 'ALL_REDUCE_MAX',
    ALL_REDUCE_MIN: 6, '6': 'ALL_REDUCE_MIN',
    ALL_REDUCE_PROD: 7, '7': 'ALL_REDUCE_PROD',
    GATHER: 8, '8': 'GATHER',
    SCATTER: 9, '9': 'SCATTER',
    ALL_TO_ALL: 10, '10': 'ALL_TO_ALL'
};

mgb.serialization.fbs.param.CondExecMarkGradMode = {
    SUM: 0, '0': 'SUM',
    SUM_COND_OUT: 1, '1': 'SUM_COND_OUT'
};

mgb.serialization.fbs.param.CondExecMarkStaticInfer = {
    SHAPE_VALUE: 0, '0': 'SHAPE_VALUE',
    SHAPE_ONLY: 1, '1': 'SHAPE_ONLY',
    NONE: 2, '2': 'NONE'
};

mgb.serialization.fbs.param.CondExecMergeMode = {
    EXACT_ONE: 0, '0': 'EXACT_ONE',
    EXACT_ONE_SAME_SHAPE: 1, '1': 'EXACT_ONE_SAME_SHAPE',
    SUM: 2, '2': 'SUM',
    SUM_COND_OUT: 3, '3': 'SUM_COND_OUT'
};

mgb.serialization.fbs.param.CondExecPredMode = {
    CASE: 0, '0': 'CASE',
    CASE_FALLBACK: 1, '1': 'CASE_FALLBACK',
    PIECEWISE: 2, '2': 'PIECEWISE'
};

mgb.serialization.fbs.param.CondExecPredLogicalMode = {
    OR: 0, '0': 'OR',
    AND: 1, '1': 'AND',
    XOR: 2, '2': 'XOR',
    NOR: 3, '3': 'NOR',
    NAND: 4, '4': 'NAND',
    XNOR: 5, '5': 'XNOR'
};

mgb.serialization.fbs.param.ExecutionPolicyStrategy = {
    HEURISTIC: 0, '0': 'HEURISTIC',
    PROFILE: 1, '1': 'PROFILE',
    REPRODUCIBLE: 2, '2': 'REPRODUCIBLE',
    OPTIMIZED: 3, '3': 'OPTIMIZED'
};

mgb.serialization.fbs.param.ExecutionPolicyV0Strategy = {
    HEURISTIC: 0, '0': 'HEURISTIC',
    HEURISTIC_REPRODUCIBLE: 1, '1': 'HEURISTIC_REPRODUCIBLE',
    PROFILE: 2, '2': 'PROFILE',
    PROFILE_REPRODUCIBLE: 3, '3': 'PROFILE_REPRODUCIBLE',
    PROFILE_HEURISTIC: 4, '4': 'PROFILE_HEURISTIC'
};

mgb.serialization.fbs.param.DType = class DType {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.DType();
        $.dtype = reader.int8_(position, 4, 8);
        return $;
    }
};

mgb.serialization.fbs.param.PersistentOutputStorage = class PersistentOutputStorage {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PersistentOutputStorage();
        $.share_key = reader.int32_(position, 4, -1);
        return $;
    }
};

mgb.serialization.fbs.param.OptionalAxis = class OptionalAxis {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.OptionalAxis();
        $.axis = reader.int32_(position, 4, -1);
        return $;
    }
};

mgb.serialization.fbs.param.OptionalAxisV1 = class OptionalAxisV1 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.OptionalAxisV1();
        $.axis = reader.int32_(position, 4, 7);
        return $;
    }
};

mgb.serialization.fbs.param.ExecutionPolicyV0 = class ExecutionPolicyV0 {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ExecutionPolicyV0();
        $.strategy = reader.uint32_(position, 4, 0);
        $.workspace_limit = reader.uint64_(position, 6, 18446744073709552000n);
        return $;
    }
};

mgb.serialization.fbs.param.ExecutionPolicy = class ExecutionPolicy {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.ExecutionPolicy();
        $.strategy = reader.uint32_(position, 4, 1);
        $.workspace_limit = reader.uint64_(position, 6, 18446744073709552000n);
        return $;
    }
};

mgb.serialization.fbs.param.AssertEqual = class AssertEqual {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AssertEqual();
        $.maxerr = reader.float32_(position, 4, 0.0001);
        $.verbose = reader.bool_(position, 6, false);
        return $;
    }
};

mgb.serialization.fbs.param.FpgaConv = class FpgaConv {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.FpgaConv();
        $.need_output_quantize = reader.bool_(position, 4, false);
        $.need_output_threshold = reader.bool_(position, 6, false);
        $.stride = reader.int32_(position, 8, 1);
        $.input_bit_width = reader.int32_(position, 10, 2);
        $.output_bit_width = reader.int32_(position, 12, 2);
        $.weight_bit_width = reader.int32_(position, 14, 2);
        $.thres0 = reader.int32_(position, 16, 0);
        $.thres1 = reader.int32_(position, 18, 1);
        $.unpool_size = reader.uint32_(position, 20, 4);
        $.direct_size = reader.uint32_(position, 22, 4);
        return $;
    }
};

mgb.serialization.fbs.param.CollectiveComm = class CollectiveComm {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CollectiveComm();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.FakeSerializedDType = class FakeSerializedDType {

    static decode(/* reader, position */) {
        const $ = new mgb.serialization.fbs.param.FakeSerializedDType();
        return $;
    }
};

mgb.serialization.fbs.param.CondExecPred = class CondExecPred {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CondExecPred();
        $.mode = reader.uint32_(position, 4, 0);
        $.eps = reader.float32_(position, 6, 0.0001);
        return $;
    }
};

mgb.serialization.fbs.param.CondExecPredLogical = class CondExecPredLogical {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CondExecPredLogical();
        $.mode = reader.uint32_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CondExecMark = class CondExecMark {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CondExecMark();
        $.grad_mode = reader.uint32_(position, 4, 0);
        $.static_infer = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.CondExecMerge = class CondExecMerge {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.CondExecMerge();
        $.nr_output = reader.uint32_(position, 4, 1);
        $.mode = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.NvOf = class NvOf {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.NvOf();
        $.precision = reader.uint32_(position, 4, 1);
        return $;
    }
};

mgb.serialization.fbs.param.PersistentDTypeScalar = class PersistentDTypeScalar {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.PersistentDTypeScalar();
        $.dtype = reader.int8(position + 0);
        $.storage = reader.read(position + 1, 4);
        return $;
    }
};

mgb.serialization.fbs.param.MGBAddUpdate = class MGBAddUpdate {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MGBAddUpdate();
        $.alpha = reader.struct(position, 4, mgb.serialization.fbs.param.PersistentDTypeScalar);
        $.beta = reader.struct(position, 6, mgb.serialization.fbs.param.PersistentDTypeScalar);
        $.bias = reader.struct(position, 8, mgb.serialization.fbs.param.PersistentDTypeScalar);
        return $;
    }
};

mgb.serialization.fbs.param.Host2DeviceCopy = class Host2DeviceCopy {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Host2DeviceCopy();
        $.enable_value_infer = reader.bool_(position, 4, true);
        $.dump_default_value = reader.bool_(position, 6, false);
        $.allow_cpu_mem_fwd = reader.bool_(position, 8, true);
        return $;
    }
};

mgb.serialization.fbs.param.Dimshuffle = class Dimshuffle {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.Dimshuffle();
        $.pattern = reader.array(position, 4, Int32Array);
        $.ndim = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.param.AxisDescMethod = {
    ADD_1: 0, '0': 'ADD_1',
    REMOVE: 1, '1': 'REMOVE'
};

mgb.serialization.fbs.param.AxisDesc = class AxisDesc {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AxisDesc();
        $.method = reader.int8(position + 0);
        $.axis = reader.int32(position + 4);
        return $;
    }
};

mgb.serialization.fbs.param.AxisAddRemove = class AxisAddRemove {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.AxisAddRemove();
        $.desc = reader.structs(position, 4, mgb.serialization.fbs.param.AxisDesc);
        return $;
    }
};

mgb.serialization.fbs.param.MGBSleep = class MGBSleep {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.MGBSleep();
        $.device = reader.bool_(position, 4, true);
        $.host = reader.bool_(position, 6, false);
        $.seconds = reader.float64_(position, 8, 0);
        return $;
    }
};

mgb.serialization.fbs.param.IndexDescMaskItem = class IndexDescMaskItem {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.IndexDescMaskItem();
        $.axis = reader.int8(position + 0);
        $.begin = reader.bool(position + 1);
        $.end = reader.bool(position + 2);
        $.step = reader.bool(position + 3);
        $.idx = reader.bool(position + 4);
        return $;
    }
};

mgb.serialization.fbs.param.IndexDescMaskDump = class IndexDescMaskDump {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.IndexDescMaskDump();
        $.items = reader.structs(position, 4, mgb.serialization.fbs.param.IndexDescMaskItem);
        return $;
    }
};

mgb.serialization.fbs.param.NMSKeep = class NMSKeep {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.param.NMSKeep();
        $.iou_thresh = reader.float32_(position, 4, 0);
        $.max_output = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization = mgb.serialization || {};

mgb.serialization.fbs = mgb.serialization.fbs || {};

mgb.serialization.fbs.v2 = mgb.serialization.fbs.v2 || {};

mgb.serialization.fbs.v2.CompNode = class CompNode {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.CompNode();
        $.logical_locator = reader.string_(position, 4, null);
        return $;
    }
};

mgb.serialization.fbs.v2.DefaultTensorFormat = class DefaultTensorFormat {

    static decode(/* reader, position */) {
        const $ = new mgb.serialization.fbs.v2.DefaultTensorFormat();
        return $;
    }
};

mgb.serialization.fbs.v2.Image2DPackedTensorFormat = class Image2DPackedTensorFormat {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Image2DPackedTensorFormat();
        $.align_axis = reader.uint8_(position, 4, 0);
        return $;
    }
};

mgb.serialization.fbs.v2.LowbitsAlignedTensorFormat = class LowbitsAlignedTensorFormat {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.LowbitsAlignedTensorFormat();
        $.size_nbits = reader.uint8_(position, 4, 0);
        $.align_size_in_bits = reader.uint8_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.v2.TensorFormat = class {

    static decode(reader, position, type) {
        switch (type) {
            case 1: return mgb.serialization.fbs.v2.DefaultTensorFormat.decode(reader, position);
            case 2: return mgb.serialization.fbs.v2.Image2DPackedTensorFormat.decode(reader, position);
            case 3: return mgb.serialization.fbs.v2.LowbitsAlignedTensorFormat.decode(reader, position);
            default: return undefined;
        }
    }
};

mgb.serialization.fbs.v2.Blob = class Blob {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Blob();
        $.data = reader.array(position, 4, Uint8Array);
        return $;
    }
};

mgb.serialization.fbs.v2.Tensor = class Tensor {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Tensor();
        $.name = reader.string_(position, 4, null);
        $.shape = reader.array(position, 6, Uint32Array);
        $.comp_node = reader.table(position, 8, mgb.serialization.fbs.v2.CompNode);
        $.dtype = reader.table(position, 10, mgb.serialization.fbs.DType);
        $.format = reader.union(position, 12, mgb.serialization.fbs.v2.TensorFormat);
        $.data = reader.array(position, 16, Uint8Array);
        return $;
    }
};

mgb.serialization.fbs.v2.Reserved0 = class Reserved0 {

    static decode(/* reader, position */) {
        const $ = new mgb.serialization.fbs.v2.Reserved0();
        return $;
    }
};

mgb.serialization.fbs.v2.DeprecatedParam = class DeprecatedParam {

    static decode(/* reader, position */) {
        const $ = new mgb.serialization.fbs.v2.DeprecatedParam();
        return $;
    }
};

mgb.serialization.fbs.v2.OperatorParam = class {

    static decode(reader, position, type) {
        switch (type) {
            case 1: return mgb.serialization.fbs.param.Empty.decode(reader, position);
            case 2: return mgb.serialization.fbs.param.Axis.decode(reader, position);
            case 3: return mgb.serialization.fbs.param.Convolution.decode(reader, position);
            case 4: return mgb.serialization.fbs.param.MaskPropagate.decode(reader, position);
            case 5: return mgb.serialization.fbs.param.ConvPooling.decode(reader, position);
            case 6: return mgb.serialization.fbs.param.ConvBias.decode(reader, position);
            case 7: return mgb.serialization.fbs.param.SeparableConv.decode(reader, position);
            case 8: return mgb.serialization.fbs.param.Images2Neibs.decode(reader, position);
            case 9: return mgb.serialization.fbs.param.Pooling.decode(reader, position);
            case 10: return mgb.serialization.fbs.param.LRN.decode(reader, position);
            case 11: return mgb.serialization.fbs.param.BN.decode(reader, position);
            case 12: return mgb.serialization.fbs.param.ROIPooling.decode(reader, position);
            case 13: return mgb.serialization.fbs.param.WarpPerspective.decode(reader, position);
            case 14: return mgb.serialization.fbs.param.SpatialTfGridGenerator.decode(reader, position);
            case 15: return mgb.serialization.fbs.param.SpatialTfSampler.decode(reader, position);
            case 16: return mgb.serialization.fbs.param.MGBAddUpdate.decode(reader, position);
            case 17: return mgb.serialization.fbs.param.Elemwise.decode(reader, position);
            case 18: return mgb.serialization.fbs.param.ElemwiseMultiType.decode(reader, position);
            case 19: return mgb.serialization.fbs.param.PowC.decode(reader, position);
            case 20: return mgb.serialization.fbs.param.MatrixMul.decode(reader, position);
            case 21: return mgb.serialization.fbs.v2.DeprecatedParam.decode(reader, position);
            case 22: return mgb.serialization.fbs.param.SVD.decode(reader, position);
            case 23: return mgb.serialization.fbs.param.Reduce.decode(reader, position);
            case 24: return mgb.serialization.fbs.param.Cumsum.decode(reader, position);
            case 25: return mgb.serialization.fbs.param.CondTake.decode(reader, position);
            case 26: return mgb.serialization.fbs.param.Argsort.decode(reader, position);
            case 27: return mgb.serialization.fbs.param.IndexingRemap.decode(reader, position);
            case 28: return mgb.serialization.fbs.param.MGBSleep.decode(reader, position);
            case 29: return mgb.serialization.fbs.param.Linspace.decode(reader, position);
            case 30: return mgb.serialization.fbs.param.LinspaceFull.decode(reader, position);
            case 31: return mgb.serialization.fbs.param.Eye.decode(reader, position);
            case 32: return mgb.serialization.fbs.param.UniformRNG.decode(reader, position);
            case 33: return mgb.serialization.fbs.param.GaussianRNG.decode(reader, position);
            case 34: return mgb.serialization.fbs.param.Flip.decode(reader, position);
            case 35: return mgb.serialization.fbs.param.Rotate.decode(reader, position);
            case 36: return mgb.serialization.fbs.param.ROICopy.decode(reader, position);
            case 37: return mgb.serialization.fbs.param.CvtColor.decode(reader, position);
            case 38: return mgb.serialization.fbs.param.WarpAffine.decode(reader, position);
            case 39: return mgb.serialization.fbs.param.GaussianBlur.decode(reader, position);
            case 40: return mgb.serialization.fbs.param.Resize.decode(reader, position);
            case 41: return mgb.serialization.fbs.param.Convolution3D.decode(reader, position);
            case 42: return mgb.serialization.fbs.param.Conv3DBias.decode(reader, position);
            case 43: return mgb.serialization.fbs.param.SeparableConv3D.decode(reader, position);
            case 44: return mgb.serialization.fbs.param.TopK.decode(reader, position);
            case 45: return mgb.serialization.fbs.param.RelayoutFormat.decode(reader, position);
            case 46: return mgb.serialization.fbs.param.SeparableFilter.decode(reader, position);
            case 47: return mgb.serialization.fbs.param.LocalShare.decode(reader, position);
            case 48: return mgb.serialization.fbs.param.ROIAlign.decode(reader, position);
            case 49: return mgb.serialization.fbs.param.DeformablePSROIPooling.decode(reader, position);
            case 50: return mgb.serialization.fbs.param.BatchConvBias.decode(reader, position);
            case 51: return mgb.serialization.fbs.param.DType.decode(reader, position);
            case 52: return mgb.serialization.fbs.param.PersistentOutputStorage.decode(reader, position);
            case 53: return mgb.serialization.fbs.param.OptionalAxis.decode(reader, position);
            case 54: return mgb.serialization.fbs.param.OptionalAxisV1.decode(reader, position);
            case 55: return mgb.serialization.fbs.param.ExecutionPolicy.decode(reader, position);
            case 56: return mgb.serialization.fbs.param.AssertEqual.decode(reader, position);
            case 57: return mgb.serialization.fbs.param.FpgaConv.decode(reader, position);
            case 58: return mgb.serialization.fbs.param.CollectiveComm.decode(reader, position);
            case 59: return mgb.serialization.fbs.param.CondExecPred.decode(reader, position);
            case 60: return mgb.serialization.fbs.param.CondExecPredLogical.decode(reader, position);
            case 61: return mgb.serialization.fbs.param.CondExecMark.decode(reader, position);
            case 62: return mgb.serialization.fbs.param.CondExecMerge.decode(reader, position);
            case 63: return mgb.serialization.fbs.param.Host2DeviceCopy.decode(reader, position);
            case 64: return mgb.serialization.fbs.param.Dimshuffle.decode(reader, position);
            case 65: return mgb.serialization.fbs.param.AxisAddRemove.decode(reader, position);
            case 66: return mgb.serialization.fbs.param.IndexDescMaskDump.decode(reader, position);
            case 67: return mgb.serialization.fbs.DType.decode(reader, position);
            case 68: return mgb.serialization.fbs.param.Remap.decode(reader, position);
            case 69: return mgb.serialization.fbs.param.NMSKeep.decode(reader, position);
            case 70: return mgb.serialization.fbs.param.AdaptivePooling.decode(reader, position);
            case 71: return mgb.serialization.fbs.param.NvOf.decode(reader, position);
            case 72: return mgb.serialization.fbs.param.DctChannelSelect.decode(reader, position);
            case 73: return mgb.serialization.fbs.param.FakeQuant.decode(reader, position);
            case 74: return mgb.serialization.fbs.param.TQT.decode(reader, position);
            case 75: return mgb.serialization.fbs.param.Correlation.decode(reader, position);
            case 76: return mgb.serialization.fbs.param.LSQ.decode(reader, position);
            case 77: return mgb.serialization.fbs.param.GammaRNG.decode(reader, position);
            case 78: return mgb.serialization.fbs.param.PoissonRNG.decode(reader, position);
            case 79: return mgb.serialization.fbs.param.PermutationRNG.decode(reader, position);
            case 80: return mgb.serialization.fbs.param.BetaRNG.decode(reader, position);
            case 81: return mgb.serialization.fbs.param.SlidingWindowTranspose.decode(reader, position);
            case 82: return mgb.serialization.fbs.param.Padding.decode(reader, position);
            case 83: return mgb.serialization.fbs.param.ShuffleRNG.decode(reader, position);
            case 84: return mgb.serialization.fbs.param.CheckNonFinite.decode(reader, position);
            case 85: return mgb.serialization.fbs.param.LayerNorm.decode(reader, position);
            case 86: return mgb.serialization.fbs.param.Dropout.decode(reader, position);
            case 87: return mgb.serialization.fbs.param.RNNCell.decode(reader, position);
            case 88: return mgb.serialization.fbs.param.RNN.decode(reader, position);
            case 89: return mgb.serialization.fbs.param.LSTM.decode(reader, position);
            case 90: return mgb.serialization.fbs.param.Softmax.decode(reader, position);
            case 91: return mgb.serialization.fbs.param.Diag.decode(reader, position);
            case 92: return mgb.serialization.fbs.param.GroupNorm.decode(reader, position);
            case 93: return mgb.serialization.fbs.param.Fill.decode(reader, position);
            default: return undefined;
        }
    }
};

mgb.serialization.fbs.v2.Operator = class Operator {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Operator();
        $.type = reader.string_(position, 4, null);
        $.type_id = reader.uint64_(position, 6, 0n);
        $.name = reader.string_(position, 8, null);
        $.param = reader.union(position, 10, mgb.serialization.fbs.v2.OperatorParam);
        $.additional_params = reader.unions(position, 14, mgb.serialization.fbs.v2.OperatorParam);
        $.inputs = reader.array(position, 18, Uint32Array);
        $.outputs = reader.array(position, 20, Uint32Array);
        $.comp_node = reader.tables(position, 22, mgb.serialization.fbs.v2.CompNode);
        $.output_dtype = reader.table(position, 24, mgb.serialization.fbs.DType);
        $.tensors = reader.tables(position, 26, mgb.serialization.fbs.v2.Tensor);
        $.opr_version = reader.uint32_(position, 28, 0);
        $.priority = reader.int32_(position, 30, 0);
        $.custom_data = reader.tables(position, 32, mgb.serialization.fbs.v2.Blob);
        return $;
    }
};

mgb.serialization.fbs.v2.Metadata = class Metadata {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Metadata();
        $.is_valid = reader.bool_(position, 4, false);
        $.graph_modified = reader.bool_(position, 6, false);
        $.optimize_options = reader.uint64_(position, 8, 0n);
        $.user_info = reader.string_(position, 10, null);
        return $;
    }
};

mgb.serialization.fbs.v2.MiddleTensor = class MiddleTensor {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.MiddleTensor();
        $.name = reader.string_(position, 4, null);
        $.shape = reader.array(position, 6, Uint32Array);
        $.comp_node = reader.table(position, 8, mgb.serialization.fbs.v2.CompNode);
        $.dtype = reader.table(position, 10, mgb.serialization.fbs.DType);
        $.format = reader.union(position, 12, mgb.serialization.fbs.v2.TensorFormat);
        return $;
    }
};

mgb.serialization.fbs.v2.OutputVar = class OutputVar {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.OutputVar();
        $.compact_id = reader.uint32_(position, 4, 0);
        $.original_id = reader.uint32_(position, 6, 0);
        return $;
    }
};

mgb.serialization.fbs.v2.OutputAlias = class OutputAlias {

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.OutputAlias();
        $.id = reader.uint32_(position, 4, 0);
        $.name = reader.string_(position, 6, null);
        return $;
    }
};

mgb.serialization.fbs.v2.Model = class Model {

    static identifier(reader) {
        return reader.identifier === 'mge2';
    }

    static create(reader) {
        return mgb.serialization.fbs.v2.Model.decode(reader, reader.root);
    }

    static decode(reader, position) {
        const $ = new mgb.serialization.fbs.v2.Model();
        $.mge_version = reader.uint32_(position, 4, 0);
        $.model_version = reader.uint32_(position, 6, 0);
        $.oprs = reader.tables(position, 8, mgb.serialization.fbs.v2.Operator);
        $.middle_tensors = reader.tables(position, 10, mgb.serialization.fbs.v2.MiddleTensor);
        $.output_vars_idx = reader.tables(position, 12, mgb.serialization.fbs.v2.OutputVar);
        $.output_alias = reader.tables(position, 14, mgb.serialization.fbs.v2.OutputAlias);
        $.nr_shared_tensor = reader.uint32_(position, 16, 0);
        $.metadata = reader.table(position, 18, mgb.serialization.fbs.v2.Metadata);
        return $;
    }
};